Serverless Architecture

What Serverless Architecture Actually Means

Serverless architecture runs code without managing servers. You write functions; the cloud provider handles provisioning, scaling, and infrastructure. You pay only for actual compute time. AWS Lambda, Google Cloud Functions, and Cloudflare Workers are examples.

When to Use It (and When Not To)

Serverless eliminates operational overhead for many use cases. There are no servers to patch, no capacity to plan, and no idle resources to pay for. It is ideal for event-driven workloads, APIs, and background processing.

The Architecture

You write a function (e.g., processOrder in Node.js) and deploy to AWS Lambda. You configure a trigger (API Gateway for HTTP, SQS for queue messages). When a request arrives, Lambda allocates a container, loads your function, executes it, and returns the result. If 1000 requests arrive simultaneously, Lambda spins up 1000 containers.

After 15 minutes of no traffic, containers are destroyed. You pay nothing until the next request.

Key Principles

• Functions as a Service (FaaS): Write individual functions that are triggered by events (HTTP requests, queue messages, file uploads).
• Auto-scaling: The platform scales from zero to thousands of instances automatically based on demand.
• Pay-per-use: Charged per invocation and compute time. Zero traffic = zero cost.
• Stateless: Functions are ephemeral — each invocation starts fresh. Use external storage (DynamoDB, S3) for state.
• Cold starts: The first invocation after idle time takes longer (100ms-10s) because the platform must initialize the runtime.

Who Does This Well

Coca-Cola uses AWS Lambda for their vending machine backend — processing payments and inventory updates.

iRobot (Roomba) uses Lambda to process robot telemetry data from millions of devices.

Figma uses Cloudflare Workers for edge API processing, reducing latency for global users.

The Hard Parts Nobody Talks About

1. Using serverless for long-running jobs — use containers or VMs instead
2. Not accounting for cold start latency in latency-sensitive applications
3. Vendor lock-in — deeply integrating with one provider's serverless ecosystem

The Tradeoffs

• No servers to manage vs Less control: You cannot tune OS settings, install custom runtimes, or control placement.
• Cost at scale: Serverless is cheap at low volume but can be expensive at high volume (compared to reserved instances).
• Cold starts: First request after idle is slow. Mitigate with provisioned concurrency (pre-warmed containers).
• Execution limits: Lambda has a 15-minute timeout, 10GB memory limit, and 6MB response size limit.

Interview Angles

1. When is serverless appropriate?
2. What are cold starts and how do you mitigate them?
3. What are the limitations of serverless?
4. How does serverless handle state?

Keep Learning

• event-driven
• microservices
• client-server

The Real-World Incident That Made This Famous

Understanding Serverless became critical after multiple high-profile production incidents at major tech companies. When systems handle millions of users, even small misunderstandings about Serverless can lead to cascading failures that cost millions in lost revenue and erode user trust. Companies like Netflix, Google, Amazon, and Meta have all invested heavily in mastering Serverless because they learned the hard way that ignoring it leads to outages.

The key lesson from these incidents: Serverless is not just a theoretical concept — it is a practical skill that separates engineers who build resilient systems from those who build fragile ones.

How Senior Engineers Think About This

Senior engineers approach Serverless differently from textbook definitions. Instead of memorizing rules, they build mental models. They ask: "What problem does Serverless solve? When does it fail? What are the alternatives?" This problem-first thinking leads to better design decisions because every system has unique constraints.

When evaluating Serverless in a system design context, experienced engineers consider the failure modes first. What happens when this component goes down? How does the system degrade? Is the degradation graceful or catastrophic? These questions reveal more about your understanding than any textbook definition.

Common Interview Mistakes

Mistake 1: Giving a textbook definition without context. Interviewers want to see you connect Serverless to real systems and real problems.

Mistake 2: Not discussing trade-offs. Every design decision involving Serverless has trade-offs. Discuss what you gain and what you give up.

Mistake 3: Overcomplicating the solution. Start with the simplest approach to Serverless that meets the requirements, then add complexity only when justified.

Production Checklist

• Define clear metrics for measuring the effectiveness of your Serverless implementation
• Set up monitoring and alerting that specifically tracks Serverless-related failures
• Document your Serverless design decisions in Architecture Decision Records (ADRs)
• Test failure scenarios related to Serverless in staging before production deployment
• Review and update your Serverless implementation quarterly as system requirements evolve
• Train new team members on the specific Serverless patterns used in your system

Read the original source | Content from System-Design-Overview

Practical Implementation for .NET Developers

In a .NET application, you would typically implement this pattern using the following approach:

ASP.NET Core setup: Create a service class that encapsulates the logic, register it with dependency injection, and inject it into your controllers or minimal API endpoints. The built-in DI container handles lifecycle management.

Entity Framework Core: For database interactions, EF Core provides the ORM layer. Use migrations for schema management and raw SQL for performance-critical queries. Consider Dapper for read-heavy paths where EF Core's overhead matters.

Azure integration: If deploying to Azure, leverage managed services — Azure Cache for Redis, Azure SQL, Azure Service Bus, Azure Cosmos DB. These eliminate operational overhead and provide built-in monitoring through Application Insights.

Testing: Use xUnit with Testcontainers for integration tests that spin up real databases in Docker. Mock external dependencies with NSubstitute. The WebApplicationFactory class lets you test your entire HTTP pipeline in-process.

Monitoring: Add Application Insights telemetry to track request latency, dependency calls, and custom metrics. Use structured logging with Serilog to make production debugging possible:

Log.Information("Processing order {OrderId} for {CustomerId}", orderId, customerId);

This gives you searchable, structured logs in Azure Monitor or Seq.