# function as a service

Function as a service (FaaS) is a cloud-computing service that runs code in response to events while the provider manages the underlying infrastructure, allowing developers to focus on application functions.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Vercel Functions now support request bodies up to 20MiB

DevFeed: [Vercel Functions now support request bodies up to 20MiB](<https://devfeed.tech/articles/vercel-functions-now-support-request-bodies-up-to-20mib-146818.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/vercel-functions-now-support-request-bodies-up-to-20mib>)

Author: Shohei Maeda

Published: 2026-11-20T13:00:00Z

Content type: release

Language: en

Sources: [Vercel News](<https://devfeed.tech/sources/vercel-news.md>)

Topics: [Vercel](<https://devfeed.tech/topics/vercel.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [payload](<https://devfeed.tech/topics/payload.md>), [Bun](<https://devfeed.tech/topics/bun.md>), [Python](<https://devfeed.tech/topics/python.md>), [return](<https://devfeed.tech/topics/return.md>)

Tags: [beta](<https://devfeed.tech/tags/beta.md>), [body](<https://devfeed.tech/tags/body.md>), [bun](<https://devfeed.tech/tags/bun.md>), [edge](<https://devfeed.tech/tags/edge.md>), [environment](<https://devfeed.tech/tags/environment.md>), [function](<https://devfeed.tech/tags/function.md>), [functions](<https://devfeed.tech/tags/functions.md>), [handling](<https://devfeed.tech/tags/handling.md>), [header](<https://devfeed.tech/tags/header.md>), [headers](<https://devfeed.tech/tags/headers.md>), [large](<https://devfeed.tech/tags/large.md>), [memory](<https://devfeed.tech/tags/memory.md>), [middleware](<https://devfeed.tech/tags/middleware.md>), [next](<https://devfeed.tech/tags/next.md>), [next-js](<https://devfeed.tech/tags/next-js.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [public](<https://devfeed.tech/tags/public.md>), [request](<https://devfeed.tech/tags/request.md>), [support](<https://devfeed.tech/tags/support.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Vercel Functions can accept request bodies up to 20 MiB in Public Beta, up from 4.5 MB. Enable the project-wide setting for an environment with `VERCEL_SUPPORT_LARGE_REQUEST_BODY=1`; it requires the 4 GB performance memory setting. The higher limit supports Node.js, Python, and Bun functions and Routing Middleware. Edge runtime functions and middleware remain capped at 4.5 MB and return 413 for oversized bodies; use the Node.js runtime to access the higher limit. With the setting enabled, middleware still runs and receives headers and metadata, but not the body, so body-dependent middleware behavior is unavailable. The source says this avoids duplicating body delivery and recommends reading large bodies promptly rather than retaining them in memory to reduce backpressure and memory issues.

### Source excerpt

Vercel Functions now accept inbound request bodies up to 20MiB, up from 4.5MB, in Public Beta. To turn this on, set the VERCEL_SUPPORT_LARGE_REQUEST_BODY=1 environment variable. The opt-in applies to the whole project in the environment where you set it, so you can test the larger limit on preview before enabling it in production. It requires the project's functions to use the performance memory setting of 4GB. It applies to functions on the Node.js, Python, and Bun runtimes, and to Routing Middleware. Functions and Routing Middleware on the Edge runtime keep the 4.5MB cap and return 413 on oversize bodies, so moving them onto the larger limit means switching to the Node.js runtime with runtime: 'nodejs', or proxy.ts in Next.js. When a project opts in, Routing Middleware receives request headers and metadata but no request body, enforced at the project level. Middleware still runs and still sees every other request header, so body-dependent middleware behavior is the one thing that becomes unavailable. This avoids sending the body twice, to both middleware and the target function, which would raise cost and time to first byte. When handling larger request bodies, read the body promptly and avoid holding it in memory to prevent backpressure and memory issues. Learn more in the Vercel Functions limitations documentation. Read more

## AWS Lambda Durable Functions observability with OpenTelemetry

DevFeed: [AWS Lambda Durable Functions observability with OpenTelemetry](<https://devfeed.tech/articles/aws-lambda-durable-functions-observability-with-opentelemetry-144754.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/compute/aws-lambda-durable-functions-observability-with-opentelemetry/>)

Author: Ricardo Marques

Published: 2026-11-19T19:09:43Z

Content type: tutorial

Language: en

Sources: [AWS Compute Blog](<https://devfeed.tech/sources/aws-compute-blog.md>)

Topics: [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>), [tracing](<https://devfeed.tech/topics/tracing.md>), [observability](<https://devfeed.tech/topics/observability.md>), [serverless monitoring](<https://devfeed.tech/topics/serverless-monitoring.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Amazon CloudWatch](<https://devfeed.tech/topics/amazon-cloudwatch.md>), [Amazon CloudWatch Logs](<https://devfeed.tech/topics/amazon-cloudwatch-logs.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [durable-execution](<https://devfeed.tech/tags/durable-execution.md>), [durable-functions](<https://devfeed.tech/tags/durable-functions.md>), [observability](<https://devfeed.tech/tags/observability.md>), [opentelemetry](<https://devfeed.tech/tags/opentelemetry.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [span](<https://devfeed.tech/tags/span.md>), [trace](<https://devfeed.tech/tags/trace.md>)

### AI overview

The `aws-durable-execution-sdk-python-otel` plugin assigns deterministic trace IDs so invocations of one AWS Lambda Durable Functions execution can appear as a unified trace, with spans reflecting operation wall-clock time and avoiding duplicate spans during replay. Setup requires Python 3.11+, the ADOT Lambda layer, X-Ray active tracing and write permissions, and passing `InvocationOtelPlugin` to the durable execution handler. The post distinguishes execution view, which groups work under the workflow span but depends on the vendor's span-ingestion window, from invocation view, which can export shorter invocation spans sooner; the final workflow span still covers the full execution and may be rejected if too old. Logger enrichment adds trace and span IDs to logs by default. The ADOT layer adds cold-start and memory overhead (about 40-60 MB); the post recommends measuring impact, naming durable operations, and using sampling to manage trace costs. The excerpt's walkthrough covers a sequential workflow with a human approval callback, not every SDK primitive or failure path.

### Source excerpt

A single AWS Lambda Durable Functions workflow can span many invocations, fragmenting its traces. This post shows how the OpenTelemetry plugin for the AWS Durable Execution SDK generates deterministic trace IDs that unify every invocation into one distributed trace, and how to set it up, read the traces, and apply best practices.

## AWS Lambda now supports GPU instances for Event Functions on Lambda Managed Instances

DevFeed: [AWS Lambda now supports GPU instances for Event Functions on Lambda Managed Instances](<https://devfeed.tech/articles/aws-lambda-now-supports-gpu-instances-for-event-functions-on-lambda-managed-instances-141088.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/aws/aws-lambda-now-supports-gpu-instances-for-event-functions-on-lambda-managed-instances/>)

Author: Daniel Abib

Published: 2026-11-18T19:39:07Z

Content type: release

Language: en

Sources: [AWS News Blog](<https://devfeed.tech/sources/aws-news-blog.md>)

Topics: [AWS Lambda](<https://devfeed.tech/topics/aws-lambda.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [GPU rendering](<https://devfeed.tech/topics/gpu-rendering.md>), [Amazon EventBridge](<https://devfeed.tech/topics/amazon-eventbridge.md>), [Transformers](<https://devfeed.tech/topics/transformers.md>)

Tags: [all](<https://devfeed.tech/tags/all.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [auto-scaling](<https://devfeed.tech/tags/auto-scaling.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [compute](<https://devfeed.tech/tags/compute.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [driver](<https://devfeed.tech/tags/driver.md>), [ec2](<https://devfeed.tech/tags/ec2.md>), [event](<https://devfeed.tech/tags/event.md>), [functions](<https://devfeed.tech/tags/functions.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpu-utilization](<https://devfeed.tech/tags/gpu-utilization.md>), [inference](<https://devfeed.tech/tags/inference.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [learning](<https://devfeed.tech/tags/learning.md>), [like](<https://devfeed.tech/tags/like.md>), [machine](<https://devfeed.tech/tags/machine.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [managed](<https://devfeed.tech/tags/managed.md>), [management](<https://devfeed.tech/tags/management.md>), [serverless](<https://devfeed.tech/tags/serverless.md>)

### AI overview

AWS Lambda Managed Instances now support GPU-accelerated Event Functions on EC2 G-series instances. Deploy a container image and connect it to a Lambda capacity provider; Lambda handles provisioning, scaling, GPU drivers, routing, and AWS event integration. Functions support concurrent requests per execution environment, and Lambda reports GPU utilization and memory metrics. The feature is aimed at inference and other GPU workloads, with support for images up to 32 GB, up to 32 GB ephemeral storage, and timeouts up to 90 minutes for specified asynchronous and event source mapping invocations. The example deploys a Hugging Face model using Lambda's vLLM image and an OpenAI-compatible request interface; publishing a version provisions environments and warms the model before callers invoke it. Users may need to request G-series quota. Pricing is EC2 instance cost, plus a 9.75% GPU management fee and standard Lambda request charges; Savings Plans and Reserved Instances apply.

### Source excerpt

AWS Lambda now supports GPU instances (G-series) for Event Functions running on Lambda Managed Instances, enabling serverless GPU workloads like machine learning inference, media processing, and rendering. Lambda handles all infrastructure tasks, including instance lifecycle, driver management, and auto scaling, while maximizing GPU utilization across concurrent requests with standard EC2 pricing plus a management fee

## Reconciling Strict SLOs with Low Cost under Fine-Grained Load Fluctuations

DevFeed: [Reconciling Strict SLOs with Low Cost under Fine-Grained Load Fluctuations](<https://devfeed.tech/articles/reconciling-strict-slos-with-low-cost-under-fine-grained-load-fluctuations-127790.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2606.30533>)

Author: Dilina Dehigama, Shyam Jesalpura, Zeyu Xu, Marton Nemeth, Shengda Zhu, Marios Kogias, Boris Grot

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [cloud cost management](<https://devfeed.tech/topics/cloud-cost-management.md>), [Load Balancing](<https://devfeed.tech/topics/load-balancing.md>), [hosting](<https://devfeed.tech/topics/hosting.md>)

Tags: [accounting](<https://devfeed.tech/tags/accounting.md>), [application](<https://devfeed.tech/tags/application.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [autoscalers](<https://devfeed.tech/tags/autoscalers.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-based](<https://devfeed.tech/tags/cloud-based.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [controller](<https://devfeed.tech/tags/controller.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cost-efficiency](<https://devfeed.tech/tags/cost-efficiency.md>), [cost-optimization](<https://devfeed.tech/tags/cost-optimization.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cpu-utilization](<https://devfeed.tech/tags/cpu-utilization.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [deployments](<https://devfeed.tech/tags/deployments.md>), [load](<https://devfeed.tech/tags/load.md>), [slos](<https://devfeed.tech/tags/slos.md>)

### AI overview

Spandana separates SLO enforcement from cost optimization for services facing sub-second load swings. A lightweight controller on each application VM keeps requests there when they can meet the SLO and sends the rest to a stock FaaS layer such as AWS Lambda. A resource allocator chooses VM provisioning based on VM and FaaS costs and traffic volatility. The reported evaluation finds strict SLO adherence, 76-86% CPU utilization, and 5-44% lower cost than three state-of-the-art baselines. The supplied text does not provide details about the evaluation setup or individual baselines.

### Source excerpt

arXiv:2606.30533v2 Announce Type: replace Abstract: Cloud-based online services face significant sub-second load fluctuations while needing to meet strict Service Level Objectives (SLOs). Cluster operators often over-provision resources to protect SLOs, sacrificing utilization and cost efficiency. Existing reactive and proactive autoscalers, serverless (FaaS) deployments, and VM/FaaS hybrid systems fail to reconcile strict SLO compliance with low cost and high utilization under fine-grained load fluctuation. We introduce Spandana, an architecture that addresses this trade off by decoupling SLO enforcement from cost optimization. A lightweight controller colocated with each application VM enforces SLOs by steering each arriving request between the VM and FaaS. Requests that can meet the SLO stay on the VM; the remaining requests are forwarded to a stock FaaS layer such as AWS Lambda. For cost optimization, Spandana's resource allocator determines the most-efficient VM provisioning by accounting for VM cost, FaaS cost, and traffic volatility, allowing the VM pool to run at high utilization. Our evaluation shows that Spandana maintains strict SLO adherence, achieves 76-86% CPU utilization, and reduces cost by 5-44% over three SOTA baselines.

## Energy-Proportional Serverless Computing on SBC Clusters

DevFeed: [Energy-Proportional Serverless Computing on SBC Clusters](<https://devfeed.tech/articles/energy-proportional-serverless-computing-on-sbc-clusters-127812.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14026>)

Author: Yuliya Sasinskaya, Natalie Carl, Niklas Kowallik, David Bermbach

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Sustainable Computing](<https://devfeed.tech/topics/sustainable-computing.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [autoscaling](<https://devfeed.tech/topics/autoscaling.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>)

Tags: [clusters](<https://devfeed.tech/tags/clusters.md>), [computing](<https://devfeed.tech/tags/computing.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [energy](<https://devfeed.tech/tags/energy.md>), [sbc](<https://devfeed.tech/tags/sbc.md>), [serverless](<https://devfeed.tech/tags/serverless.md>)

### AI overview

A tinyFaaS platform for single-board computer clusters extends serverless scale-to-zero to physical nodes by including node power state in worker selection: idle workers are powered off and restarted under load. On a physical cluster, it reduced mean power draw by 39.6% for a bursty trace-based workload and 46.7% for a sparse workload. Median latency on the bursty workload showed no detectable change, but invocations arriving when all workers were off waited about a minute for a node to boot. Under continuous load, it behaved like an always-on cluster.

### Source excerpt

arXiv:2611.14026v1 Announce Type: new Abstract: Serverless computing promises to run code only on demand, yet the servers beneath it draw most of their power while idle, so energy consumption does not scale to zero with the workload. We show that the statelessness of serverless functions makes it possible to extend scale-to-zero from function instances to physical nodes, enabling energy proportionality. Our platform, built on tinyFaaS for clusters of single-board computers, treats node power state as part of worker selection, powering workers off when idle and back on under load. On a physical cluster, our approach reduces mean power draw by 39.6 % on a bursty, trace-based workload and by 46.7 % on a sparse one, without a detectable change in median latency on the bursty workload. The cost lands in the tail, where invocations that arrive while all workers are off wait about a minute for a node to boot. Under continuous load, the platform behaves like an always-on cluster.

## Right-Size AWS Transform MGN Replication Servers

DevFeed: [Right-Size AWS Transform MGN Replication Servers](<https://devfeed.tech/articles/right-size-aws-transform-mgn-replication-servers-121785.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/migration-and-modernization/right-size-aws-transform-mgn-replication-servers/>)

Author: Rajamuthu Sundaram

Published: 2026-11-06T11:35:00Z

Content type: tutorial

Language: en

Sources: [Migration & Modernization](<https://devfeed.tech/sources/migration-modernization.md>)

Topics: [AWS Transform](<https://devfeed.tech/topics/aws-transform.md>), [Amazon EC2](<https://devfeed.tech/topics/amazon-ec2.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Amazon Elastic Block Store (Amazon EBS)](<https://devfeed.tech/topics/amazon-elastic-block-store-amazon-ebs.md>), [Amazon EventBridge](<https://devfeed.tech/topics/amazon-eventbridge.md>)

Tags: [amazon](<https://devfeed.tech/tags/amazon.md>), [amazon-ec2](<https://devfeed.tech/tags/amazon-ec2.md>), [amazon-elastic-compute](<https://devfeed.tech/tags/amazon-elastic-compute.md>), [amazon-elastic-compute-cloud-amazon-ec2](<https://devfeed.tech/tags/amazon-elastic-compute-cloud-amazon-ec2.md>), [application](<https://devfeed.tech/tags/application.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-application-migration-service](<https://devfeed.tech/tags/aws-application-migration-service.md>), [aws-transform](<https://devfeed.tech/tags/aws-transform.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [compute](<https://devfeed.tech/tags/compute.md>), [customer-solutions](<https://devfeed.tech/tags/customer-solutions.md>), [ec2](<https://devfeed.tech/tags/ec2.md>), [elastic](<https://devfeed.tech/tags/elastic.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [migration](<https://devfeed.tech/tags/migration.md>), [replication](<https://devfeed.tech/tags/replication.md>), [right](<https://devfeed.tech/tags/right.md>), [servers](<https://devfeed.tech/tags/servers.md>), [size](<https://devfeed.tech/tags/size.md>), [technical-how-to](<https://devfeed.tech/tags/technical-how-to.md>)

### AI overview

A Lambda function can evaluate non-archived AWS Transform MGN source servers in one configured account and Region, sum their provisioned disk capacity, and map them to configurable exact EC2 replication-server instance tiers. It reports proposed changes in dry-run mode by default and, when an authorized caller invokes apply mode, updates eligible servers to higher managed tiers. Servers with incomplete disk inventory, unmanaged types, or equal or lower targets are skipped. The example requires Terraform 1.3+, Python 3.12 Lambda, deployment and target-account IAM setup, approved instance types and quotas, and a change window. Capacity is only a policy signal: the function does not measure used space, write rate, replication lag, transfer volume, or completion time, and its tiers are not sizing recommendations or performance guarantees. Updates are not transactional; review dry-run results and validate each changed server. The sample does not scale down automatically; operators may manually restore a smaller approved type after synchronization. Test runtime and throttling for fleet size, and monitor replication and cost.

### Source excerpt

Migration teams need a consistent way to right-size AWS Transform MGN replication servers when a wave includes many source servers. The challenge grows when source servers range from small systems to workloads with several tebibytes of provisioned disk capacity. AWS Transform MGN, formerly AWS Application Migration Service, uses lightweight Amazon Elastic Compute Cloud (Amazon EC2) [...]

## Save tokens with Neon Function templates

DevFeed: [Save tokens with Neon Function templates](<https://devfeed.tech/articles/save-tokens-with-neon-function-templates-121156.md>)

Original publisher: [Read original article](<https://neon.com/blog/save-tokens-with-neon-function-templates>)

Author: Dominik Koch

Published: 2026-11-05T12:00:00Z

Content type: release

Language: en

Sources: [Neon Docs](<https://devfeed.tech/sources/blog-neon-docs.md>)

Topics: [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [function calling](<https://devfeed.tech/topics/function-calling.md>), [self-service](<https://devfeed.tech/topics/self-service.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [bootstrap](<https://devfeed.tech/tags/bootstrap.md>), [code](<https://devfeed.tech/tags/code.md>), [function](<https://devfeed.tech/tags/function.md>), [neon](<https://devfeed.tech/tags/neon.md>), [product](<https://devfeed.tech/tags/product.md>), [registry](<https://devfeed.tech/tags/registry.md>), [save](<https://devfeed.tech/tags/save.md>), [skip](<https://devfeed.tech/tags/skip.md>), [template](<https://devfeed.tech/tags/template.md>), [templates](<https://devfeed.tech/tags/templates.md>), [tokens](<https://devfeed.tech/tags/tokens.md>)

### AI overview

Neon Function Registry templates give agents working Neon Function code, pinned dependencies, and a README with required services and an example request, reducing the need to research setup before coding. The collection includes examples using Chat SDK, Mastra, TanStack AI, Context.dev, Postgres, AI Gateway, Object Storage, and Managed Better Auth. Agents can list template IDs with `neon functions templates list` and install without prompts using `neon functions new <id> -y`; creating a template does not require a linked project or signed-in CLI. Deployment requires Neon CLI 8.11.0 or later and a directory linked to a Neon project. Setup may involve installing dependencies, adding services, defining environment variables, and deploying with `--env .env.local` when templates use their own variables. Installed files remain editable and are not overwritten by template updates. Most templates do not authenticate callers, so authentication should be added before sharing URLs that call paid services.

### Source excerpt

Agents can already bootstrap a Neon Function on their own, but they spend tokens researching best practices first. A template from the Neon Function Registry lets them skip that and start from working code.

## AtomicFaaS: Offloading Side-Effect Compensation to the Serverless Platform

DevFeed: [AtomicFaaS: Offloading Side-Effect Compensation to the Serverless Platform](<https://devfeed.tech/articles/atomicfaas-offloading-side-effect-compensation-to-the-serverless-platform-119116.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06601>)

Author: Jonas Heisterberg, Sebastian Koch, Trever Schirmer, David Bermbach

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [developer](<https://devfeed.tech/tags/developer.md>), [developers](<https://devfeed.tech/tags/developers.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [effect](<https://devfeed.tech/tags/effect.md>), [effects](<https://devfeed.tech/tags/effects.md>), [extension](<https://devfeed.tech/tags/extension.md>), [faas](<https://devfeed.tech/tags/faas.md>), [failure](<https://devfeed.tech/tags/failure.md>), [function](<https://devfeed.tech/tags/function.md>), [function-as-a-service](<https://devfeed.tech/tags/function-as-a-service.md>), [function-as-a-service-faas](<https://devfeed.tech/tags/function-as-a-service-faas.md>), [latency](<https://devfeed.tech/tags/latency.md>), [load](<https://devfeed.tech/tags/load.md>), [offloading](<https://devfeed.tech/tags/offloading.md>), [platform](<https://devfeed.tech/tags/platform.md>), [retries](<https://devfeed.tech/tags/retries.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [throughput](<https://devfeed.tech/tags/throughput.md>)

### AI overview

AtomicFaaS moves compensation for failed serverless invocations from developers to the platform. It intercepts outbound calls and records their effects in a fault-tolerant log, allowing the platform to compensate effects left behind when a function fails or its instance crashes. Against a manually implemented saga, the authors report eliminating compensation code and leaving no compensatable effects after tested failures. Each intercepted call adds about 1 ms; under load, CPU-bound functions have lower sustainable throughput, while latency overhead becomes negligible when external service calls dominate invocation time. This summary is based on the supplied abstract.

### Source excerpt

arXiv:2611.06601v1 Announce Type: new Abstract: Function-as-a-Service (FaaS) simplifies distributed application development by offloading operational concerns to the platform, but developers remain responsible for recovering from failures. Retries require idempotent functions, which means that developers have to write complex, error-prone code that undoes or skips the already completed operations of a failed function. To address this, we propose AtomicFaaS, a platform extension that provides semantic atomicity for the external side effects of a function invocation, whether the function fails or its instance crashes, without developer-written compensation code. AtomicFaaS intercepts outbound calls and records their effects in a fault-tolerant log, from which the platform compensates leaked effects outside the failed instance. Compared with a manually implemented saga, AtomicFaaS eliminates compensation code and leaves no compensatable effects after any tested failure, while adding ~1 ms per intercepted call. Under load, it lowers the sustainable throughput of CPU-bound functions, while its latency overhead becomes negligible once calls to external services dominate the invocation time.

## Characterizing Serverless Workloads: A Large-Scale Analysis of Function-as-a-Service Platforms

DevFeed: [Characterizing Serverless Workloads: A Large-Scale Analysis of Function-as-a-Service Platforms](<https://devfeed.tech/articles/characterizing-serverless-workloads-a-large-scale-analysis-of-function-as-a-service-platforms-116503.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.05081>)

Author: Saman Akbari, Yassine Lazreg, Mohammadreza Malekabbasi, Manfred Hauswirth

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [function-as-a-service-faas](<https://devfeed.tech/tags/function-as-a-service-faas.md>), [serverless](<https://devfeed.tech/tags/serverless.md>)

### AI overview

The study analyzes eight public FaaS workload traces from Alibaba, Azure, Huawei, IBM, and Globus. It reports that invocation patterns remain broadly similar, while shorter execution times shift performance pressure toward platform scheduling and dependency management. The traces also show growing use of concurrent, long-lived containers to reduce cold starts, resource over-provisioning, and highly skewed request volumes. The authors suggest these findings can inform targeted cold-start mitigation, predictive resource management, and dependency-aware scheduling.

### Source excerpt

arXiv:2611.05081v1 Announce Type: new Abstract: Serverless computing is a popular approach to application deployment without having to manage the underlying infrastructure. Its most common implementation is Function-as-a-Service (FaaS), in which applications are structured as fine-grained functions. FaaS providers face non-trivial tasks in the management of their platforms, including cold starts, auto-scaling, and scheduling. The design of optimized platforms requires an accurate understanding of realistic serverless workloads. However, existing research and platforms rely on insights from single, often outdated datasets. In this work, we conduct a large-scale, cross-platform comparative analysis of eight publicly available FaaS workload traces from major cloud providers (Alibaba, Azure, Huawei, IBM) and a scientific computing platform (Globus). We provide a comprehensive and up-to-date view of the serverless ecosystem by characterizing key dimensions such as invocation patterns, latency, cold start behavior, and resource utilization. Our analysis shows that although invocation patterns remain universal, execution times have shortened, shifting the performance bottleneck toward platform scheduling and dependency management. We also observe an architectural shift toward "Serverless 2.0" models, where concurrent, long-lived containers are increasingly utilized to bypass cold start penalties. Furthermore, we found resource over-provisioning and extreme skew in user request volumes. These findings provide actionable insights for designing more efficient FaaS platforms, informing improved approaches to targeted cold start mitigation, predictive resource management, and dependency-aware scheduling.

## Incident report: Sites & Functions runtime vulnerability, November 1st, 2026

DevFeed: [Incident report: Sites & Functions runtime vulnerability, November 1st, 2026](<https://devfeed.tech/articles/incident-report-sites-functions-runtime-vulnerability-november-1st-2026-117840.md>)

Original publisher: [Read original article](<https://appwrite.io/blog/post/incident-report-sites-functions-runtime-vulnerability>)

Author: Luke B. Silver

Published: 2026-11-04T00:00:00Z

Content type: news

Language: en

Sources: [Appwrite Blog](<https://devfeed.tech/sources/appwrite-blog.md>)

Topics: [Post Mortem](<https://devfeed.tech/topics/post-mortem.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [exploit chaining](<https://devfeed.tech/topics/exploit-chaining.md>), [reliability-engineering](<https://devfeed.tech/topics/reliability-engineering.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2026](<https://devfeed.tech/tags/2026.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [ai](<https://devfeed.tech/tags/ai.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [api](<https://devfeed.tech/tags/api.md>), [api-key](<https://devfeed.tech/tags/api-key.md>), [api-keys](<https://devfeed.tech/tags/api-keys.md>), [exploited](<https://devfeed.tech/tags/exploited.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [functions](<https://devfeed.tech/tags/functions.md>), [incident](<https://devfeed.tech/tags/incident.md>), [incident-report](<https://devfeed.tech/tags/incident-report.md>), [report](<https://devfeed.tech/tags/report.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [secrets](<https://devfeed.tech/tags/secrets.md>), [security](<https://devfeed.tech/tags/security.md>), [sites](<https://devfeed.tech/tags/sites.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

On November 1, 2026, an attacker exploited unsafe file handling in an Appwrite Frankfurt service after running code in their own project, exposing internal credentials. One token could read environment variables from Functions and Sites on the Frankfurt compute for about 11 hours. Appwrite found no evidence that this token was used to read variables, but cannot rule it out because its infrastructure provider's audit log is incomplete. The attacker's recorded activity was aimed at one customer; Appwrite says other observed actions included reading that customer's function code and logs, briefly replacing its function code, and accessing only the attacker's own storage files. Appwrite fixed the vulnerabilities, replaced credentials, and blocked the attacker's accounts. It notified owners of 1,022 projects meeting specific Frankfurt runtime and secret-variable criteria. Notified customers should rotate qualifying secrets, update variables, and redeploy; self-hosted users should upgrade to 2.7.1.

### Source excerpt

How Appwrite detected and fixed a Sites and Functions runtime vulnerability exploited on November 1st, 2026, who is affected, and which secrets to rotate.

## Same Function, Different CPU: Quantifying Hardware Heterogeneity in Commercial FaaS Platforms

DevFeed: [Same Function, Different CPU: Quantifying Hardware Heterogeneity in Commercial FaaS Platforms](<https://devfeed.tech/articles/same-function-different-cpu-quantifying-hardware-heterogeneity-in-commercial-faas-platforms-113821.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.02990>)

Author: Jonas Heisterberg, Natalie Carl, Trever Schirmer, David Bermbach

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [cloud cost management](<https://devfeed.tech/topics/cloud-cost-management.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [abstraction](<https://devfeed.tech/tags/abstraction.md>), [alibaba](<https://devfeed.tech/tags/alibaba.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [availability](<https://devfeed.tech/tags/availability.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [azure](<https://devfeed.tech/tags/azure.md>), [azure-functions](<https://devfeed.tech/tags/azure-functions.md>), [bill](<https://devfeed.tech/tags/bill.md>), [can](<https://devfeed.tech/tags/can.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-run](<https://devfeed.tech/tags/cloud-run.md>), [composition](<https://devfeed.tech/tags/composition.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [faas](<https://devfeed.tech/tags/faas.md>), [function](<https://devfeed.tech/tags/function.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [platforms](<https://devfeed.tech/tags/platforms.md>)

### AI overview

Across four commercial FaaS platforms, hardware differences can strongly affect function performance and duration-based cost, though their role varies by provider. Variance decomposition attributes 4% to 97% of performance variance to CPU heterogeneity on AWS Lambda and Google Cloud Run Functions. On Azure Functions, a platform-level mechanism creates bimodal execution durations and overshadows CPU effects. AWS Lambda's CPU composition shifts within a week, while CPU types on Google Cloud Run Functions and Alibaba Function Compute differ in instruction extensions such as SHA-NI, widening performance gaps. The slowest CPU type can cost up to three times as much per invocation as the fastest.

### Source excerpt

arXiv:2611.02990v1 Announce Type: new Abstract: Serverless computing, particularly Function-as-a-Service (FaaS), abstracts operational concerns such as scaling, scheduling, and resource management from users. This abstraction, however, conceals a heterogeneous hardware fleet on which function execution environments are scheduled behind a unified function interface. Consequently, otherwise identical invocations may run on different CPU types that differ in performance, a hardware lottery that users can neither see nor control. Since the resulting variability is entangled with other sources, such as noisy neighbors or diurnal effects, its contribution to overall performance variability and how this contribution differs across providers remain unclear. In this paper, we systematically study hardware heterogeneity and its impact on function performance across four widely used commercial FaaS platforms, covering regional, configurational, and temporal differences. Using variance decomposition, we find that CPU heterogeneity alone explains 4 % to 97 % of the performance variance on AWS Lambda and Google Cloud Run Functions. On Azure Functions, in contrast, we identify a platform-level mechanism that produces bimodal execution durations and overshadows CPU effects. We observe that the CPU composition on AWS Lambda shifts within a single week. Additionally, we reveal that on Google Cloud Run Functions and Alibaba Function Compute, the availability of instruction set extensions such as SHA-NI differs between CPU types, widening the performance gap further. Since all platforms bill by duration, performance gaps between CPU types translate directly into cost, with invocations on the slowest CPU type costing up to three times as much as those on the fastest.

## Optimizing OpenFaaS on Kubernetes: Comparative Analysis of Language Runtimes and Cluster Distributions

DevFeed: [Optimizing OpenFaaS on Kubernetes: Comparative Analysis of Language Runtimes and Cluster Distributions](<https://devfeed.tech/articles/optimizing-openfaas-on-kubernetes-comparative-analysis-of-language-runtimes-and-cluster-distributions-107334.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2604.05496>)

Author: Ehsan Ataie, Mohammadreza Pooshani, Hossein Aqasizade

Published: 2026-10-30T04:00:00Z

Content type: comparison

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [OpenFaaS](<https://devfeed.tech/topics/openfaas.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Node.js](<https://devfeed.tech/topics/node-js.md>)

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [delay](<https://devfeed.tech/tags/delay.md>), [faas](<https://devfeed.tech/tags/faas.md>), [go](<https://devfeed.tech/tags/go.md>), [impact](<https://devfeed.tech/tags/impact.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [insights](<https://devfeed.tech/tags/insights.md>), [k3s](<https://devfeed.tech/tags/k3s.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [latency](<https://devfeed.tech/tags/latency.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [performance](<https://devfeed.tech/tags/performance.md>), [python](<https://devfeed.tech/tags/python.md>), [runtimes](<https://devfeed.tech/tags/runtimes.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [trade](<https://devfeed.tech/tags/trade.md>)

### AI overview

The study evaluates OpenFaaS on Kubeadm, K3s, MicroK8s, and K0s using CloudLab, comparing Python, Go, and Node.js functions under different levels of concurrent invocation. It measures throughput, CPU usage, and delay. The abstract reports that Go consistently achieves higher throughput and lower CPU usage than Python and Node.js. K3s and Kubeadm perform best among the Kubernetes distributions: K3s shows high throughput, while Kubeadm maintains low latency and efficient CPU usage. The excerpt does not provide detailed measurements or results for MicroK8s and K0s.

### Source excerpt

arXiv:2604.05496v2 Announce Type: replace-cross Abstract: Serverless computing, particularly Function-as-a-Service (FaaS), has revolutionized cloud computing by abstracting infrastructure management and enabling dynamic resource allocation. This paper examines the performance and compatibility of OpenFaaS, an open-source serverless platform, when deployed on various Kubernetes distributions, including Kubeadm, K3s, MicroK8s, and K0s. Moreover, leveraging the CloudLab infrastructure, this study examines the impact of Python, Go, and Node$.$js programming languages on the performance of Kubernetes-enabled OpenFaaS, specifically when these languages are used to develop functions deployed on the platform. The performance is evaluated and analyzed under various levels of concurrent invocations using several usage-level metrics, such as throughput and CPU usage, as well as responsiveness metrics, such as delay. According to our findings, Go consistently outperforms Python and Node$.$js in terms of throughput and CPU usage, making it the ideal runtime for serverless applications. Among the Kubernetes distributions, K3s and Kubeadm exhibit superior performance, with Kubeadm maintaining low latency and efficient CPU usage, and K3s demonstrating high throughput. This study provides valuable insights into optimizing the Kubernetes-enabled OpenFaaS platform, highlighting the strengths and trade-offs of different Kubernetes distributions and language runtimes.

## Announcing email triggers for Appwrite Functions

DevFeed: [Announcing email triggers for Appwrite Functions](<https://devfeed.tech/articles/announcing-email-triggers-for-appwrite-functions-109520.md>)

Original publisher: [Read original article](<https://appwrite.io/blog/post/announcing-function-email-triggers>)

Author: Torsten Dittmann

Published: 2026-10-30T00:00:00Z

Content type: tutorial

Language: en

Sources: [Appwrite Blog](<https://devfeed.tech/sources/appwrite-blog.md>)

Topics: [Appwrite](<https://devfeed.tech/topics/appwrite.md>), [email](<https://devfeed.tech/topics/email.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [also](<https://devfeed.tech/tags/also.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [application](<https://devfeed.tech/tags/application.md>), [apps](<https://devfeed.tech/tags/apps.md>), [async](<https://devfeed.tech/tags/async.md>), [automated](<https://devfeed.tech/tags/automated.md>), [built-in](<https://devfeed.tech/tags/built-in.md>), [can](<https://devfeed.tech/tags/can.md>), [connect](<https://devfeed.tech/tags/connect.md>), [custom](<https://devfeed.tech/tags/custom.md>), [custom-domain](<https://devfeed.tech/tags/custom-domain.md>), [domain](<https://devfeed.tech/tags/domain.md>), [email](<https://devfeed.tech/tags/email.md>), [function](<https://devfeed.tech/tags/function.md>), [functions](<https://devfeed.tech/tags/functions.md>), [records](<https://devfeed.tech/tags/records.md>), [triggers](<https://devfeed.tech/tags/triggers.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Appwrite Cloud Functions can run when an email arrives, with Appwrite parsing it into a `multipart/form-data` request containing email JSON and separate attachment files. Enable the trigger per function; its built-in `<FUNCTION_ID>-<PROJECT_ID>.appwrite.email` address needs no DNS, while a custom domain requires an MX record and a `_appwrite.mail` TXT verification record. Appwrite does not retain messages or attachments. Delivery has practical caveats: function errors are still acknowledged without a sender bounce, while failures to run or finish in time can prompt sender retries. Retries may execute functions again, so compare `messageId` to detect duplicates. Spam scores are provided as hints and do not cause Appwrite to reject mail; test expected messages before filtering. Email triggers are available on Appwrite Cloud.

### Source excerpt

Appwrite Functions can now execute when an email arrives. Each function has a built-in email address, and you can connect a custom domain with MX and TXT records.

## Cloud Service Models Explained: IaaS vs PaaS vs SaaS

DevFeed: [Cloud Service Models Explained: IaaS vs PaaS vs SaaS](<https://devfeed.tech/articles/cloud-service-models-explained-iaas-vs-paas-vs-saas-107184.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/cloud-service-models-explained-iaas-vs-paas-vs-saas/>)

Author: Chinwendu Enyinna

Published: 2026-10-29T15:39:58Z

Content type: article

Language: en

Sources: [Free Code Camp](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [The Three Main Cloud Service Models](<https://devfeed.tech/topics/the-three-main-cloud-service-models.md>), [Comparing SaaS, PaaS, and IaaS](<https://devfeed.tech/topics/comparing-saas-paas-and-iaas.md>), [Use Cases for Every Cloud Service Model](<https://devfeed.tech/topics/use-cases-for-every-cloud-service-model.md>), [Shared Responsibility Model](<https://devfeed.tech/topics/shared-responsibility-model.md>), [Infrastructure as a Service (IaaS)](<https://devfeed.tech/topics/infrastructure-as-a-service-iaas.md>), [Platform as a Service (PaaS)](<https://devfeed.tech/topics/platform-as-a-service-paas.md>), [Software as a service](<https://devfeed.tech/topics/saas.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>)

Tags: [amazon](<https://devfeed.tech/tags/amazon.md>), [amazon-dynamodb](<https://devfeed.tech/tags/amazon-dynamodb.md>), [amazon-ec2](<https://devfeed.tech/tags/amazon-ec2.md>), [amazon-eks](<https://devfeed.tech/tags/amazon-eks.md>), [amazon-rds](<https://devfeed.tech/tags/amazon-rds.md>), [amazon-s3](<https://devfeed.tech/tags/amazon-s3.md>), [amazon-vpc](<https://devfeed.tech/tags/amazon-vpc.md>), [amazon-web-services](<https://devfeed.tech/tags/amazon-web-services.md>), [amazon-web-services-aws](<https://devfeed.tech/tags/amazon-web-services-aws.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-computing](<https://devfeed.tech/tags/cloud-computing.md>), [cloud-engineering](<https://devfeed.tech/tags/cloud-engineering.md>), [cloud-services](<https://devfeed.tech/tags/cloud-services.md>), [gmail](<https://devfeed.tech/tags/gmail.md>), [iaas](<https://devfeed.tech/tags/iaas.md>), [it](<https://devfeed.tech/tags/it.md>), [models](<https://devfeed.tech/tags/models.md>), [net](<https://devfeed.tech/tags/net.md>), [saas](<https://devfeed.tech/tags/saas.md>), [servers](<https://devfeed.tech/tags/servers.md>), [slack](<https://devfeed.tech/tags/slack.md>), [zoom](<https://devfeed.tech/tags/zoom.md>)

### AI overview

The models differ in how much of the computing stack the provider manages. With IaaS, you rent virtual servers, storage, and networking but handle the operating system, software, updates, and scaling setup. PaaS manages servers, operating systems, and runtimes so you can deploy code and data, with less control and possible platform limits or lock-in. SaaS provides a finished application; you configure users, access, and data while the provider operates and updates it. The article also describes CaaS for managed containers and FaaS for event-triggered functions billed by use; FaaS has execution limits and can have cold starts. Serverless refers to operating and billing characteristics, not a separate stack model. It recommends starting with the most managed option that meets the project's needs, while noting customers remain responsible for their data and access.

### Source excerpt

You likely use cloud services every day. When you check Gmail, join a Zoom meeting, or message your team on Slack, you use cloud-hosted software. But you don't manage the servers it runs on or maintai

## Vercel Flags starts 7x faster and no longer extends function duration

DevFeed: [Vercel Flags starts 7x faster and no longer extends function duration](<https://devfeed.tech/articles/vercel-flags-starts-7x-faster-and-no-longer-extends-function-duration-106762.md>)

Original publisher: [Read original article](<https://vercel.com/changelog/vercel-flags-starts-7x-faster-and-no-longer-extends-function-duration>)

Author: Dominik Ferber

Published: 2026-10-29T06:00:00Z

Content type: release

Language: en

Sources: [Vercel News](<https://devfeed.tech/sources/vercel-news.md>)

Topics: [Vercel](<https://devfeed.tech/topics/vercel.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [version](<https://devfeed.tech/topics/version.md>)

Tags: [faster](<https://devfeed.tech/tags/faster.md>), [function](<https://devfeed.tech/tags/function.md>), [latency](<https://devfeed.tech/tags/latency.md>), [network](<https://devfeed.tech/tags/network.md>), [reporting](<https://devfeed.tech/tags/reporting.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [update](<https://devfeed.tech/tags/update.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

The Vercel Flags SDK speeds cold-start initialization by loading the deployment's bundled flags datafile when the client is created and checking its revision from each invocation, avoiding a network request. Internal testing found p75 initialization fell from over 70 ms to 10 ms; p99 flag-read latency across cold and warm invocations is under 1 ms. Usage reporting now passes events to the Vercel runtime instead of using `waitUntil`, so it no longer extends function duration after the response. The source says to update `@flags-sdk/vercel` to version 1.5.3 or later and redeploy.

### Source excerpt

On Vercel, the Vercel Flags SDK now initializes faster on cold starts, and usage reporting no longer keeps functions running after the response. Faster cold starts Two changes speed up SDK initialization on cold starts: The SDK loads and parses the flags datafile bundled with your deployment as soon as the client is created, so it's ready before your code evaluates its first flag. Every function invocation now includes the current datafile revision, so the SDK can check whether the bundled datafile is up to date without a network request. In internal testing, eliminating the network wait reduced p75 cold-start SDK initialization time from over 70 ms to 10 ms, roughly 7x faster. After initialization, flag reads are effectively instant. Across cold and warm invocations, p99 flag-read latency is under 1 ms. Usage reporting no longer extends function duration The SDK previously used waitUntil for usage reporting, keeping functions running after the response was sent. It now passes usage events to the Vercel runtime, so reporting no longer adds to function duration. Update @flags-sdk/vercel to version 1.5.3 or later and redeploy your application: Learn more in the Flags SDK documentation. Read more

## Observing AWS Lambda durable functions with the Durable Execution Telemetry Exporter

DevFeed: [Observing AWS Lambda durable functions with the Durable Execution Telemetry Exporter](<https://devfeed.tech/articles/observing-aws-lambda-durable-functions-with-the-durable-execution-telemetry-exporter-106353.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/compute/observing-aws-lambda-durable-functions-with-the-durable-execution-telemetry-exporter/>)

Author: Pooya Paridel

Published: 2026-10-28T19:36:12Z

Content type: tutorial

Language: en

Sources: [AWS Compute Blog](<https://devfeed.tech/sources/aws-compute-blog.md>)

Topics: [serverless monitoring](<https://devfeed.tech/topics/serverless-monitoring.md>), [observability](<https://devfeed.tech/topics/observability.md>), [observability pipelines](<https://devfeed.tech/topics/observability-pipelines.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [AWS Glue](<https://devfeed.tech/topics/aws-glue.md>), [AWS Step Functions](<https://devfeed.tech/topics/aws-step-functions.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [amazon-cloudwatch](<https://devfeed.tech/tags/amazon-cloudwatch.md>), [amazon-cloudwatch-logs](<https://devfeed.tech/tags/amazon-cloudwatch-logs.md>), [amazon-eventbridge](<https://devfeed.tech/tags/amazon-eventbridge.md>), [amazon-redshift](<https://devfeed.tech/tags/amazon-redshift.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [athena](<https://devfeed.tech/tags/athena.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-glue](<https://devfeed.tech/tags/aws-glue.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [durable-execution](<https://devfeed.tech/tags/durable-execution.md>), [durable-functions](<https://devfeed.tech/tags/durable-functions.md>), [intermediate-200](<https://devfeed.tech/tags/intermediate-200.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [query](<https://devfeed.tech/tags/query.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [telemetry](<https://devfeed.tech/tags/telemetry.md>)

### AI overview

The Durable Execution Telemetry Exporter reconstructs a cumulative JSON record for each AWS Lambda durable execution from checkpointed SDK state, so teams can query steps, timing, retries, status, and errors without correlating invocation logs. A one-line SDK integration can write to CloudWatch Logs by default or route records to configured destinations; emit mode, deterministic sampling, and content transforms control frequency and exposed data. Size limits can truncate records per destination while preserving identity and timeline fields. The companion local MCP server offers read-only tools to inspect schemas, list or fetch executions, and query supported destinations; SQL queries must be SELECT or WITH ending in SELECT. Limits include no records for service-originated STOPPED or TIMED_OUT states without an invocation, dropped intermediate snapshots when exports lag, and extra replay cost when preserving child operations across resumes.

### Source excerpt

Durable functions span many Lambda invocations, so per-invocation logs answer the wrong question. The Durable Execution Telemetry Exporter is an SDK plugin that emits one complete record per execution to any of 13 destinations with a one-line change, and a companion MCP server lets an AI agent query that data in plain language.

## A Unified Queueing-Based Framework for Comparative Evaluation of Serverless Autoscaling Strategies under Bursty Workloads

DevFeed: [A Unified Queueing-Based Framework for Comparative Evaluation of Serverless Autoscaling Strategies under Bursty Workloads](<https://devfeed.tech/articles/a-unified-queueing-based-framework-for-comparative-evaluation-of-serverless-autoscaling-strategies-under-bursty-workloads-101637.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.35564>)

Author: Zahra Zafarzade, Ehsan Ataie

Published: 2026-10-27T04:00:00Z

Content type: news

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [autoscaling](<https://devfeed.tech/topics/autoscaling.md>), [queueing theory](<https://devfeed.tech/topics/queueing-theory.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Simulation](<https://devfeed.tech/topics/simulation.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [activation](<https://devfeed.tech/tags/activation.md>), [automatic](<https://devfeed.tech/tags/automatic.md>), [autoscaling](<https://devfeed.tech/tags/autoscaling.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [critical](<https://devfeed.tech/tags/critical.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [delay](<https://devfeed.tech/tags/delay.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [faas](<https://devfeed.tech/tags/faas.md>), [framework](<https://devfeed.tech/tags/framework.md>), [h2](<https://devfeed.tech/tags/h2.md>), [java](<https://devfeed.tech/tags/java.md>), [load](<https://devfeed.tech/tags/load.md>), [metric](<https://devfeed.tech/tags/metric.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [strategies](<https://devfeed.tech/tags/strategies.md>)

### AI overview

The study compares scale-per-request (SPR), concurrency-level scaling (CLS), and metric-based scaling (MBS) using a unified queueing model: analytical queueing networks combined with queueing Petri nets in Java Modeling Tools, evaluated under two-phase hyper-exponential arrivals. It tracks throughput, mean response time, system population, and power while modeling function-instance activation, concurrency limits, and queue buildup at saturation. The abstract reports a performance-stability trade-off: SPR has the lowest delay at moderate load but is fragile near capacity; CLS depends on concurrency tokens and is highly configuration-sensitive under bursty conditions; MBS provides the steadiest QoS across the tested workload range by limiting utilization and queue growth under critical load.

### Source excerpt

arXiv:2610.35564v1 Announce Type: new Abstract: Serverless computing platforms must preserve quality of service (QoS) while adapting to highly bursty and unpredictable workloads. To cope with workload fluctuations while satisfying QoS requirements and service-level agreements (SLAs), these platforms rely on automatic resource scaling. Commercial function-as-a-service (FaaS) platforms employ different autoscaling strategies to dynamically adjust the number of active function instances and the available processing capacity. In this work, three representative autoscaling strategies are modeled and compared: scale-per-request (SPR), concurrencylevel scaling (CLS), and metric-based scaling (MBS). To enable systematic evaluation independent of proprietary platform-specific implementations, we develop a unified modeling framework that combines analytical queueing network (QN) modeling with queueing Petri nets (QPN) implemented in Java Modeling Tools (JMT) to evaluate autoscaling behavior under two-phase hyper-exponential (H2) arrivals. Evaluation is conducted using four system-level metrics: throughput, mean response time, system population, and system power. The framework captures dynamic function instance (FI) activation, concurrency constraints, and queue buildup under saturation. Comparative analysis reveals a clear trade-off between peak performance and stability: SPR provides the lowest delay under moderate load but becomes fragile near capacity limits; CLS is governed by concurrency tokens and is highly sensitive to configuration under bursty conditions; whereas MBS provides the most stable QoS across the workload range by keeping utilization below a critical region and preventing explosive queue growth under critical load.

## AWS Introduces Lambda Web Functions for Node.js Applications

DevFeed: [AWS Introduces Lambda Web Functions for Node.js Applications](<https://devfeed.tech/articles/aws-introduces-lambda-web-functions-for-node-js-applications-97614.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/10/aws-lambda-web-functions/>)

Author: Renato Losio

Published: 2026-10-23T12:49:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Node.js](<https://devfeed.tech/topics/node-js.md>), [Express](<https://devfeed.tech/topics/express.md>), [Cloud Architecture](<https://devfeed.tech/topics/cloud-architecture.md>), [Web Development](<https://devfeed.tech/topics/web-development.md>), [Fastify](<https://devfeed.tech/topics/fastify.md>)

Tags: [ai-inference](<https://devfeed.tech/tags/ai-inference.md>), [amazon-cloudfront](<https://devfeed.tech/tags/amazon-cloudfront.md>), [apis](<https://devfeed.tech/tags/apis.md>), [architecture-design](<https://devfeed.tech/tags/architecture-design.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [aws-lambda-web-functions](<https://devfeed.tech/tags/aws-lambda-web-functions.md>), [azure-container-apps](<https://devfeed.tech/tags/azure-container-apps.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-architecture](<https://devfeed.tech/tags/cloud-architecture.md>), [cloud-run](<https://devfeed.tech/tags/cloud-run.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [development](<https://devfeed.tech/tags/development.md>), [express](<https://devfeed.tech/tags/express.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [hono](<https://devfeed.tech/tags/hono.md>), [news](<https://devfeed.tech/tags/news.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [web-applications](<https://devfeed.tech/tags/web-applications.md>)

### AI overview

AWS Lambda Web Functions let developers deploy standard Node.js HTTP servers and frameworks such as Express, Hono, Fastify, and Next.js directly to Lambda. One warm execution environment can handle concurrent requests, and responses can stream; billing covers active CPU time and memory, with memory charged for the environment's lifetime. Multi-Region routing sends requests to the closest Region, and CloudFront can provide custom domains, edge caching, or AWS WAF. The service targets HTTP workloads including APIs, full-stack apps, microservices, server-side rendering, and streaming. It currently supports only Node.js and is available in five Regions: Northern Virginia, Ohio, Oregon, Tokyo, and Ireland. Existing Lambda functions are now called Lambda Event Functions, with no required changes. The excerpt notes that Google Cloud Run and Azure Container Apps offer a similar adapter-free web application model, with scale-to-zero and configurable concurrency.

### Source excerpt

AWS recently introduced Lambda Web Functions, allowing developers to run Node.js web applications using frameworks such as Express and Hono directly on Lambda, with support for concurrent requests and response streaming. By Renato Losio

## CoreWeave Announces Support for NVIDIA AI Enterprise Software Platform and NVIDIA Cloud Functions

DevFeed: [CoreWeave Announces Support for NVIDIA AI Enterprise Software Platform and NVIDIA Cloud Functions](<https://devfeed.tech/articles/coreweave-announces-support-for-nvidia-ai-enterprise-software-platform-and-nvidia-cloud-functions-96100.md>)

Original publisher: [Read original article](<https://wf.coreweave.com/blog/coreweave-announces-support-for-nvidia-ai-enterprise-software-platform-and-nvidia-cloud-functions>)

Author: CoreWeave

Published: 2026-10-22T16:27:39Z

Content type: release

Language: en

Sources: [Coreweave Blog Posts](<https://devfeed.tech/sources/coreweave-blog-posts.md>)

Topics: [Nvidia](<https://devfeed.tech/topics/nvidia.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Hopper](<https://devfeed.tech/topics/hopper.md>), [NVIDIA DGX](<https://devfeed.tech/topics/nvidia-dgx.md>), [DGX Cloud](<https://devfeed.tech/topics/dgx-cloud.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-applications](<https://devfeed.tech/tags/ai-applications.md>), [applications](<https://devfeed.tech/tags/applications.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-functions](<https://devfeed.tech/tags/cloud-functions.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [content-type](<https://devfeed.tech/tags/content-type.md>), [coreweave](<https://devfeed.tech/tags/coreweave.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [enterprise-software](<https://devfeed.tech/tags/enterprise-software.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [nvidia-ai-enterprise](<https://devfeed.tech/tags/nvidia-ai-enterprise.md>), [optimize](<https://devfeed.tech/tags/optimize.md>), [performance](<https://devfeed.tech/tags/performance.md>), [platform](<https://devfeed.tech/tags/platform.md>), [scale](<https://devfeed.tech/tags/scale.md>), [software](<https://devfeed.tech/tags/software.md>), [support](<https://devfeed.tech/tags/support.md>)

### AI overview

CoreWeave announced support for NVIDIA AI Enterprise and DGX Cloud Serverless Inference powered by NVIDIA Cloud Functions (NVCF) on NVIDIA Hopper GPUs and GB200 NVL72 instances. NVIDIA AI Enterprise provides software for production generative AI pipelines, while NVCF auto-scales inference workloads, including NVIDIA NIM microservices. To deploy, customers install NVIDIA's Cluster Agent Operator on an existing CoreWeave Kubernetes Service (CKS) cluster, register it with NVCF, then create functions through the NVCF console or NGC CLI; the UI offers "Elastic NIM" for NIM microservices. CoreWeave says engineers deployed a custom-model function on GB200 NVL72. The announcement describes the integration and setup but does not provide measured performance or cost results.

### Source excerpt

CoreWeave now supports NVIDIA AI Enterprise and Cloud Functions, helping customers easily deploy, scale, and optimize AI applications on high-performance cloud infrastructure.

## Building an AEO scoring pipeline with AWS Lambda durable functions

DevFeed: [Building an AEO scoring pipeline with AWS Lambda durable functions](<https://devfeed.tech/articles/building-an-aeo-scoring-pipeline-with-aws-lambda-durable-functions-91266.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/compute/building-an-aeo-scoring-pipeline-with-aws-lambda-durable-functions/>)

Author: Nick Beall

Published: 2026-10-20T17:45:29Z

Content type: tutorial

Language: en

Sources: [AWS Compute Blog](<https://devfeed.tech/sources/aws-compute-blog.md>)

Topics: [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Amazon Bedrock](<https://devfeed.tech/topics/amazon-bedrock.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [Amazon EventBridge](<https://devfeed.tech/topics/amazon-eventbridge.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [aeo](<https://devfeed.tech/tags/aeo.md>), [agent](<https://devfeed.tech/tags/agent.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-lambda](<https://devfeed.tech/tags/aws-lambda.md>), [build](<https://devfeed.tech/tags/build.md>), [building](<https://devfeed.tech/tags/building.md>), [can](<https://devfeed.tech/tags/can.md>), [costs](<https://devfeed.tech/tags/costs.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [durable-functions](<https://devfeed.tech/tags/durable-functions.md>), [engine](<https://devfeed.tech/tags/engine.md>), [functions](<https://devfeed.tech/tags/functions.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [retries](<https://devfeed.tech/tags/retries.md>), [sam](<https://devfeed.tech/tags/sam.md>), [score](<https://devfeed.tech/tags/score.md>), [solution](<https://devfeed.tech/tags/solution.md>), [technical-how-to](<https://devfeed.tech/tags/technical-how-to.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The article describes a five-step AEO audit pipeline built as an AWS Lambda durable function: fetch a page, score it, analyze the results, publish HTML and JSON reports to Amazon S3, and record metadata in DynamoDB. Its five signals--discoverability, parsability, token efficiency, capability signaling, and access control--use deterministic Python checks for a reproducible 0-100 score; Amazon Bedrock separately generates prose findings and recommendations. Checkpoints let failed runs resume at the failed step, avoiding repeated completed work, and the function suspends between stages without incurring additional costs. An optional callback can pause for human approval. The fetch uses plain HTTP GET, so pages dependent on client-side JavaScript may score lower. Deployment requires AWS Bedrock access, AWS SAM CLI v1.100+, Python 3.12+, and CloudFormation deployment permissions; the excerpt gives `sam build && sam deploy --guided` as the deployment command.

### Source excerpt

Learn how to build a five-step Agent Engine Optimization (AEO) scoring pipeline on AWS Lambda durable functions. Each checkpointed step suspends without incurring costs between stages and retries without re-spending on prior work, so you can score any page against five AEO signals and deploy the solution with an AWS SAM template.

## Announcing function intervals: run functions every N minutes

DevFeed: [Announcing function intervals: run functions every N minutes](<https://devfeed.tech/articles/announcing-function-intervals-run-functions-every-n-minutes-85483.md>)

Original publisher: [Read original article](<https://appwrite.io/blog/post/announcing-function-intervals>)

Author: Chirag Aggarwal

Published: 2026-10-12T00:00:00Z

Content type: release

Language: en

Sources: [Appwrite Blog](<https://devfeed.tech/sources/appwrite-blog.md>)

Topics: [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>)

Tags: [announcements](<https://devfeed.tech/tags/announcements.md>), [api](<https://devfeed.tech/tags/api.md>), [cli](<https://devfeed.tech/tags/cli.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [config](<https://devfeed.tech/tags/config.md>), [cron](<https://devfeed.tech/tags/cron.md>), [data](<https://devfeed.tech/tags/data.md>), [https](<https://devfeed.tech/tags/https.md>), [jobs](<https://devfeed.tech/tags/jobs.md>), [json](<https://devfeed.tech/tags/json.md>), [node](<https://devfeed.tech/tags/node.md>), [project](<https://devfeed.tech/tags/project.md>), [region](<https://devfeed.tech/tags/region.md>), [release](<https://devfeed.tech/tags/release.md>), [scheduled](<https://devfeed.tech/tags/scheduled.md>), [self-hosted](<https://devfeed.tech/tags/self-hosted.md>), [settings](<https://devfeed.tech/tags/settings.md>)

### AI overview

Appwrite Functions adds interval-based scheduling as an alternative to cron. Developers choose an interval, and Appwrite selects a start time within it, spreading functions with matching intervals across the period. The release covers configuration through the console, SDK, and CLI, interval behavior, and plan limits; intervals are available on Appwrite Cloud and are planned for self-hosted Appwrite in a future release.

### Source excerpt

Appwrite Functions can now run on an interval as an alternative to cron. Set how often a function runs, and Appwrite picks when within each interval it starts.

## The Original Serverless Architecture is Still Here

DevFeed: [The Original Serverless Architecture is Still Here](<https://devfeed.tech/articles/the-original-serverless-architecture-is-still-here-27398.md>)

Original publisher: [Read original article](<http://engineering.khanacademy.org/posts/original-serverless.htm>)

Author: Khan Academy

Published: 2018-05-31T22:00:00Z

Content type: article

Language: en

Sources: [Khan Academy](<https://devfeed.tech/sources/khan-academy.md>)

Topics: [Serverless](<https://devfeed.tech/topics/serverless.md>), [Cloud Architecture](<https://devfeed.tech/topics/cloud-architecture.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [AWS Lambda](<https://devfeed.tech/topics/aws-lambda.md>), [scalable-architecture](<https://devfeed.tech/topics/scalable-architecture.md>), [Amazon DynamoDB](<https://devfeed.tech/topics/amazon-dynamodb.md>), [AWS Step Functions](<https://devfeed.tech/topics/aws-step-functions.md>), [Realtime Database](<https://devfeed.tech/topics/realtime-database.md>), [Amazon Aurora](<https://devfeed.tech/topics/amazon-aurora.md>)

Tags: [2018](<https://devfeed.tech/tags/2018.md>), [amazon](<https://devfeed.tech/tags/amazon.md>), [api](<https://devfeed.tech/tags/api.md>), [api-gateway](<https://devfeed.tech/tags/api-gateway.md>), [architect](<https://devfeed.tech/tags/architect.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [autoscaling](<https://devfeed.tech/tags/autoscaling.md>), [aws](<https://devfeed.tech/tags/aws.md>), [backend](<https://devfeed.tech/tags/backend.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [container](<https://devfeed.tech/tags/container.md>), [container-orchestration](<https://devfeed.tech/tags/container-orchestration.md>), [containers](<https://devfeed.tech/tags/containers.md>), [cost](<https://devfeed.tech/tags/cost.md>), [data-persistence](<https://devfeed.tech/tags/data-persistence.md>), [database](<https://devfeed.tech/tags/database.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [news](<https://devfeed.tech/tags/news.md>), [serverless](<https://devfeed.tech/tags/serverless.md>), [serverless-architecture](<https://devfeed.tech/tags/serverless-architecture.md>)

### AI overview

The article argues that App Engine remains a workable early form of serverless architecture: Khan Academy chose it to scale usage without growing its operations team, and it still provides bundled development, persistence, monitoring, and deployment features. Kubernetes offers more flexibility and cloud independence through an ecosystem of container and service-management tools, but assembling and tuning that stack takes work and may involve less mature options. Function-based serverless platforms abstract infrastructure, scale through managed services, and charge for usage, though applications require coordinating multiple functions and services; the frameworks described are young and mostly tied to one cloud provider. The author sees both approaches improving manageability and expects more ways to combine services across providers.

### Source excerpt

By Kevin Dangoor This month, my colleague Dave Rosile and I went to GlueCon 2018 in sunny Denver, ... Read more

## How Runpod Flash deploys serverless GPU functions and reduces cold starts

DevFeed: [How Runpod Flash deploys serverless GPU functions and reduces cold starts](<https://devfeed.tech/articles/cold-starts-were-never-the-real-problem-78143.md>)

Original publisher: [Read original article](<https://www.runpod.io/blog/serverless-gpu-cold-starts-flashboot>)

Author: Matt Sarrel

Published: 2026-09-13T15:06:30Z

Content type: tutorial

Language: en

Sources: [Runpod Blog.](<https://devfeed.tech/sources/runpod-blog.md>)

Topics: [Serverless](<https://devfeed.tech/topics/serverless.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [Inference](<https://devfeed.tech/topics/inference.md>)

Tags: [flash](<https://devfeed.tech/tags/flash.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [inference](<https://devfeed.tech/tags/inference.md>), [python](<https://devfeed.tech/tags/python.md>), [serverless](<https://devfeed.tech/tags/serverless.md>)

### AI overview

Runpod Flash packages Python dependencies separately from its pre-cached base image to deploy serverless GPU endpoints quickly. The article explains queue-based and load-balanced execution, autoscaling, and FlashBoot, which resumes paused containers with model weights still in GPU memory to reduce startup latency. It also describes Priority FlashBoot for production workloads that need warm capacity under contention and provides deployment examples.

### Source excerpt

Flash deploys Python functions as serverless GPU endpoints in under 30 seconds. FlashBoot cuts serverless GPU inference cold starts to under 200ms.

## How Factory scaled its cloud backend to one billion monthly requests on Vercel

DevFeed: [How Factory scaled its cloud backend to one billion monthly requests on Vercel](<https://devfeed.tech/articles/how-factory-scaled-its-cloud-backend-to-one-billion-monthly-requests-on-vercel-737.md>)

Original publisher: [Read original article](<https://vercel.com/blog/how-factory-scaled-its-cloud-backend-to-one-billion-monthly-requests-on-vercel>)

Author: Ben Sabic

Published: 2026-08-03T04:00:00Z

Content type: news

Language: en

Sources: [Vercel News](<https://devfeed.tech/sources/vercel-news.md>)

Topics: [Vercel](<https://devfeed.tech/topics/vercel.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [function as a service](<https://devfeed.tech/topics/function-as-a-service.md>), [observability](<https://devfeed.tech/topics/observability.md>), [internal developer platform automation](<https://devfeed.tech/topics/internal-developer-platform-automation.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>), [Full Stack Development](<https://devfeed.tech/topics/full-stack-development.md>)

Tags: [agile](<https://devfeed.tech/tags/agile.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [automate](<https://devfeed.tech/tags/automate.md>), [autonomy](<https://devfeed.tech/tags/autonomy.md>), [backend](<https://devfeed.tech/tags/backend.md>), [building](<https://devfeed.tech/tags/building.md>), [but](<https://devfeed.tech/tags/but.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [compute](<https://devfeed.tech/tags/compute.md>), [customer](<https://devfeed.tech/tags/customer.md>), [daily](<https://devfeed.tech/tags/daily.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [factory](<https://devfeed.tech/tags/factory.md>), [monthly](<https://devfeed.tech/tags/monthly.md>), [vercel](<https://devfeed.tech/tags/vercel.md>)

### AI overview

Factory reports that a single Next.js backend on Vercel serves its product surfaces, handling one billion daily requests through API routes, middleware, webhook handlers, and log drain pipelines. As workloads grew, the team says it needed to adjust memory limits and function duration; it reports scaling these without incident and a p95 response time of 350 ms or below. Vercel's fluid compute keeps functions warm across requests, which the excerpt credits with avoiding cold-start delays. Factory also uses Droids to configure, build, and deploy internal tools directly through Vercel's APIs, with engineers setting guardrails and reviewing high-stakes decisions; this produces dozens of deployments daily. For self-serve signup abuse, Observability surfaces traffic patterns and problematic IPs, while the Web Application Firewall applies route-level rules alongside rate limiting and DDoS protection.

### Source excerpt

Factory on Vercel One billion backend API requests served daily 350ms p95 response time Scaled backend, internal tooling, and security without a dedicated infrastructure team Factory's mission is to bring autonomy to every phase of the software development lifecycle, from signals to production. Not to replace engineering judgment, but to automate the repetitive work around it, giving engineers more time to focus on the decisions that matter most. To deliver this enterprise-grade platform, Factory adopted their ideal operation model internally: remaining lean and agile by deploying Droids to manage routine workloads, so their engineers could focus strictly on building the product. As Factory scaled from a simple web app into a multi-surface platform, serving everyone from individual developers to enterprises with tens of thousands of engineers, their backend scaled alongside them. Today, a single Next.js backend on Vercel powers every surface, handling one billion daily requests across API routes, middleware, and webhook handlers, without becoming a separate engineering project. Next.js as a full-stack backend for cloud SaaS: API routes, middleware, and backend logic at scale Most teams think of Next.js as a frontend framework. Factory runs its entire cloud backend on it: API routes handle the customer-facing API, which launched in its own section of their Next.js app Middleware manages authentication and routing logic across every surface Webhook handlers and log drain pipelines run alongside the web platform, feeding analytics downstream As Factory grew rapidly, the same backend absorbed every new workload. None of it required standing up separate infrastructure or making a new vendor decision. The only areas that required tuning were memory limits and function duration. Both scaled up without incident. Fluid compute keeps functions warm across requests, removing the cold start penalty that makes traditional serverless a liability for latency-sensitive workloads. T

[Next page](<https://devfeed.tech/topics/function-as-a-service.md?cursor=WyIyMDI2LTA4LTAzVDA0OjAwOjAwKzAwOjAwIiwgIjk1ZjJiNTZkLTBhNjctNDhjOC04Zjk2LTNlYjI3YWY5ZjExMCJd>)