|
Getting your Trinity Audio player ready...
|
Table of Contents
Amazon Prime Video’s audio and video monitoring team built a stream-quality checker on AWS Step Functions and Lambda, a textbook serverless stack. Then the design hit a hard scaling limit well below the load the team expected.
So the team folded every detector into one Amazon ECS task, kept the data in memory, and reported that infrastructure cost fell by over 90%. Adrian Cockcroft, a longtime cloud architect, called it a prototype refactor, not a retreat from serverless.
Meanwhile, Coca-Cola North America moved a vending-machine backend from EC2 instances to Lambda and reported a lower annual bill.
Same technology, opposite result. The platform was never the variable. Traffic shape was: how many requests arrive, how long each one runs, and how much memory each needs.
That distinction matters more now. Gartner predicts that 25% of organizations will have experienced significant dissatisfaction with their cloud adoption by 2028, citing unrealistic expectations, weak implementation, and uncontrolled costs. Serverless adds places to make that mistake, because the bill moves with every request.
This guide covers what serverless computing architecture is, seven workloads where it fits, the hard limits across AWS, Azure, and Google Cloud, and a worked monthly bill. Get the order wrong, and you either overpay for steady traffic or rebuild a system that hit a quota in production.
What Is Serverless Computing Architecture, and How Does It Differ From Containers and VMs?
Serverless computing architecture is a design in which the cloud provider handles provisioning, scaling, and maintenance; your code runs in response to events, and you pay for execution instead of idle capacity. Servers still exist. You just never patch, size, or reboot them.

It is also broader than Lambda. A typical stack pairs functions with managed services such as object storage, queues, and databases, and places an API gateway between users and the code.
FaaS vs BaaS: The Two Halves
Function as a service (FaaS) runs your code on demand in AWS Lambda, Azure Functions, or Google Cloud Run functions. Backend as a service (BaaS) supplies ready-made pieces such as authentication, databases, and file storage. Most serverless backends mix both.
How an Event-Driven Request Flows
A customer taps Pay. The API gateway receives the call and triggers a function. That function validates the order, writes it to a managed database, and drops a message on a queue. A second function reads the message and emails the receipt. Nothing runs between taps, and nothing bills.
Serverless vs Containers vs VMs
| Serverless vs Containers vs VMs | |||||
|---|---|---|---|---|---|
| Approach | You manage | Scaling | Billed by | Idle cost | Run-time ceiling |
| Serverless functions | Code and configuration | Automatic, per event | Requests plus GB-seconds | None | Minutes to an hour, by cloud |
| Containers | Image and scaling rules | Autoscaler you configure | vCPU and memory per hour | Yes, for the running minimum | None |
| Virtual machines | OS, patches and capacity | Scale groups you configure | Instance hour | Yes, full price | None |
Think of a restaurant that hires a chef only when a ticket prints and pays per dish. That is a bargain on a Tuesday with six orders. On a Saturday with a queue out the door, paying per dish stops being cheap.
What Are the Best Serverless Computing Use Cases?
Functions fit work that arrives in bursts, reacts to an event, or finishes fast. Three benefits explain why: scaling without a capacity plan, no charge while idle, and a smaller operations footprint.
And that last one matters if you are building a multi-tenant product, where SaaS development services often start with exactly this backend. Every use case below also carries a catch, because praise without a catch is a brochure.
| Serverless Use Cases and What to Watch For | ||
|---|---|---|
| Use case | Why it fits | Watch for |
| Web and mobile backends, REST APIs | Request-driven, scales to zero overnight | Cold starts on latency-sensitive endpoints |
| Event-driven data processing | File uploads, streams and ETL steps trigger functions | Payload and timeout caps |
| IoT backends | Millions of small device messages | Per-call cost at constant high volume |
| Scheduled jobs and automation | Run, finish, stop billing | Jobs longer than the timeout |
| Spiky or seasonal traffic | Capacity follows demand | Concurrency quotas during peaks |
| Prototypes and MVPs | No infrastructure to stand up | Refactor when traffic turns steady |
| AI inference glue and webhooks | Short orchestration around model calls | Long model calls hit time and payload ceilings |
What Are the Limits of Serverless Before You Commit?
Limits decide architecture reviews. Learn them before the review, not after the incident.
Hard Quotas: Run Time, Scale, and Payload
| Hard Quotas: Run Time, Scale, and Payload | |||
|---|---|---|---|
| Limit | AWS Lambda | Azure Functions | Google Cloud Run functions (2nd gen) |
| Run time | 15 minutes; up to 90 minutes on Lambda Managed Instances for async calls | Consumption max 10 minutes; Flex Consumption and Premium default 30 minutes with no enforced max; HTTP triggers must respond within 230 seconds | HTTP up to 60 minutes; event-driven up to 9 minutes |
| Scale | 1,000 concurrent executions per Region by default, adjustable | Flex Consumption up to 1,000 instances | 100 max instances by default for HTTP, raised to 1,000 |
| Payload | 6 MB synchronous, 1 MB asynchronous | Varies by trigger | 32 MB for HTTP requests |
Lambda’s figures come from its quotas page; Azure and Google publish theirs in their own documentation, and all three move often. Re-check them on the day you design. One date is already fixed: Azure retires the Linux Consumption plan on 30 September 2028 and points new apps to Flex Consumption.
Cold Starts: How Often and How Bad
A cold start is the delay while the platform builds a new execution environment. AWS reports that these hit a small share of production invocations and last from under 100 milliseconds to over a second. You can buy them off with provisioned concurrency on Lambda or always-ready instances on Azure. But that warm capacity bills whether or not traffic arrives, which is the idle cost serverless promised to remove.

Statelessness, Lock-In, and Debugging
Functions keep no memory between calls, so state belongs in managed stores. And lock-in is real, since triggers and integrations tie you to a provider. Thoughtworks suggests isolating core logic from platform glue with a hexagonal pattern and leaning on standards such as HTTP, SQL, and CloudEvents.
Debugging changes shape as well. One request now crosses a gateway, several functions, and a queue, so tracing and structured logs become design work, not afterthoughts.
Is Serverless Cheaper? How the Bill Actually Works
For variable traffic, usually yes. For steady, heavy traffic, often no. The bill follows three numbers: requests, duration, and memory.

The Pricing Formula
On AWS Lambda in US East (N. Virginia), x86 functions cost $0.20 per million requests plus $0.0000166667 per GB-second, according to the AWS pricing page. The free tier covers one million requests and 400,000 GB-seconds a month. A GB-second is memory in gigabytes multiplied by run time in seconds.
Worked Example: 3 Million Requests a Month
Say an API function runs for 120 ms at 1,536 MB (1.5 GB) and receives 3 million requests a month.
- Compute: 3,000,000 × 0.12 s × 1.5 GB = 540,000 GB-seconds. Subtract the 400,000 free, leaving 140,000, costing about $2.33.
- Requests: 3 million less 1 million free leaves 2 million, costing $0.40.
- Total: about $2.73 a month, before logs, which CloudWatch bills separately.
Costs People Forget
API Gateway charges per request, CloudWatch charges for log ingestion and storage, data transfer out is metered, and provisioned concurrency bills for warm capacity. On small functions, the gateway and log lines can outweigh the compute line, so price the whole path.
When Serverless Costs More Than Containers
No single break-even number exists, and online sources disagree by orders of magnitude. Trek10’s Lambda cost analysis offers a method instead: compare a function with an always-on instance at a sustained request rate.
Short, small functions stay cheaper at far higher request rates than long, memory-heavy ones. Duration and memory move the line more than the platform does, and Prime Video sat on the wrong side of it.
How Do You Decide If Serverless Fits Your Workload?
| Does Serverless Fit Your Workload? | ||
|---|---|---|
| Signal | Good fit | Warning |
| Traffic | Bursty or unpredictable | Steady and high-volume |
| Run time | Short, event-triggered | Jobs beyond the timeout |
| Latency | Tolerates a rare delay | Tight budgets a cold start would break |
| Team | Small, no dedicated operations | Needs host-level tuning |
| Stage | MVP or scheduled job | Mature system with known flat load |
The Hybrid Path
Cockcroft recommends running a sustained-traffic prototype as an autoscaled container inside a wider serverless, event-driven design. Functions keep the triggers, glue, and spiky work, while containers take the hot, steady path. Especially with traffic that turns steady after launch, treating functions and containers as two halves of one system, not a verdict on either, is what saves the rewrite.
Ace Infoway builds cloud-based web applications across PaaS, IaaS, serverless, and SaaS models, so the split gets decided per workload. Its cloud development services start from your request rate, duration, and memory, not from a platform preference.
Conclusion
Amazon Prime Video and Coca-Cola ran the same technology and landed in opposite directions. Serverless wins on variable, event-driven work and loses on steady, heavy, latency-critical work. Pull thirty days of request logs for your busiest service, run them through the formula above, and price the whole path before you pick a side.






