Using Feature Flags Safely in Production

Serverless architecture removes the burden of managing servers and automatically scales with demand, but it is not a universal upgrade over traditional infrastructure — the right choice depends on your workload's traffic pattern and latency sensitivity. Serverless functions remove the burden of managing servers and scale automatically, which is genuinely useful for spiky, unpredictable workloads like image processing or webhook handling.

The tradeoffs show up with cold starts affecting latency-sensitive requests, and costs that can become unpredictable at very high, sustained traffic compared to a fixed server.

We use serverless selectively, for background jobs and event-driven tasks, while keeping core request-handling on traditional infrastructure when latency and cost predictability matter more.

Cold starts deserve more attention than they usually get in vendor marketing: a function that has not run recently can take anywhere from tens of milliseconds to a few seconds to initialise, depending on runtime and package size, which is a poor experience for a user-facing API endpoint that needs consistent sub-100ms responses. Techniques like provisioned concurrency help but add back some of the cost predictability serverless was meant to solve.

Cost is the other area where intuition often fails. Serverless pricing is attractive at low and moderate volume because you only pay for actual execution time, but at high, sustained throughput a small fleet of always-on servers is frequently cheaper than paying per invocation, especially once you factor in data transfer and orchestration costs between functions.

A common pitfall is decomposing an application into too many small functions too early, which turns debugging into tracing a request across a dozen separate logs and cold-start boundaries. We generally recommend starting with fewer, coarser-grained functions and splitting further only once a specific piece of the workload demonstrably needs independent scaling.

Our default pattern for clients is a mixed architecture: a persistent server or container handles the core, latency-sensitive request path, while serverless functions pick up asynchronous work like thumbnail generation, email sending, or third-party webhook processing, where a slightly variable response time is invisible to the end user.