- Market
- Saudi Arabia
- Written for
- CTO
- Decision
- Decide where serverless fits a workload and where its trade-offs rule it out
Scaling to zero
What scaling to zero gives you and what it quietly costs
We do not have an office in Saudi Arabia
We serve organisations there from our Riyadh office and our engineering hubs in Lahore and Karachi, travelling for the parts of an engagement that need to happen in person.
The defining feature of serverless is that it scales to zero: when nothing is happening, nothing is running, and nothing is billed. For a workload that spends most of its life idle and then spikes — a webhook that fires a few times an hour, a nightly job, an API whose traffic is bursty and hard to predict — this is a real advantage. You are not paying to keep a server warm for the ninety per cent of the time it does nothing, and when the spike comes the platform adds capacity without you provisioning it. That economics, plus not patching or sizing a fleet, is the genuine case for serverless, and for the right workload it is a strong one.
The cost is on the other side of the same coin. Because nothing was running, the first request after an idle period pays a cold start while the platform spins the function up — usually milliseconds to a couple of seconds, negligible for a background job and unacceptable on a latency-critical path. The programming model ties you more tightly to one provider’s primitives than a container would, so moving later is real work. And observability is harder: instead of one long-lived process you have many brief executions, and understanding a failure across them takes tooling you have to set up deliberately. None of these rules serverless out; all of them belong in the decision, because the workloads that suit it and the ones that fight it are separated exactly by whether these costs land where it hurts.
Fit by workload
The workloads serverless fits and the ones it punishes
Serverless is not better or worse than always-on compute in general; it is decisively right for some shapes of work and decisively wrong for others. These are the cases, separated by how the trade-offs land.
| Option | Why serverless fits | Where the trade-offs bite | Best for |
|---|---|---|---|
| Event-driven, bursty work | Idle most of the time then spiking, so scaling to zero saves real money and a cold start is invisible in the background. | Little — this is where serverless is the clear answer. | Serverless as the natural fit |
| A steady, high-throughput service | Rarely — constant traffic means you are always paying per invocation with no idle to save. | At sustained volume, always-on compute is cheaper and the per-request pricing works against you. | Always-on compute, reserved capacity |
| A latency-critical request path | Only with warming or provisioned concurrency, which erodes the cost advantage that justified serverless. | A cold start on a user-facing call is a visible stall, so the model fights the requirement. | Always-warm compute for the hot path |
Price them in
The trade-offs to price in before a function reaches production
These are the costs teams discover after they commit, when they should be decided before. Each is manageable; none is free, and treating them as afterthoughts is what turns a good serverless fit into a bad experience.
Cold starts on the first request
After idle, a function pays a start-up delay before it serves. Invisible for a background job, a stall for a user waiting — so the fix, warming or provisioned concurrency, is a cost decided against the latency you actually need.
A tighter tie to one provider
Serverless functions lean on a provider’s event sources, triggers and managed services, which binds the design to that provider more than a container does. It is not a trap to avoid, but a cost to enter knowingly, so a future move is a planned project rather than a surprise.
Observability across many executions
Behaviour is spread across many short-lived invocations instead of one process, so tracing a request and diagnosing a failure need distributed tracing and aggregation set up on purpose, not the logs a single server would have given you.
Cost that inverts at scale
Per-invocation pricing is cheap when work is intermittent and expensive when it is constant. A workload that grows from spiky to steady can quietly cross the point where always-on compute would be cheaper, so the cost model is revisited as usage changes.
Our role
What we put on serverless and what we keep on always-on compute
- 01
The boundary, drawn first
We identify which parts of a workload are genuinely event-driven and spiky and belong on serverless, and which are steady or latency-critical and should not, because a mixed system usually wants both.
- 02
Trade-offs on the table
We put cold starts, lock-in, observability and the cost curve into the decision before the first function ships, so they are choices you made rather than surprises you met in production.
- 03
Observability built in, not bolted on
Where we build serverless, we set up the tracing and aggregation that make a distributed execution debuggable from the start, so the hardest part of the model is handled rather than deferred.
What latency your users will accept and how your traffic actually behaves are yours to state; we translate that into a boundary between serverless and always-on compute, with the trade-offs priced in, so scaling to zero is an advantage you collect rather than a surprise you absorb.
Common questions
What buyers ask
Does serverless actually save money, or does it just move the cost around?+
It saves money for a specific shape of workload and costs more for another, so the honest answer depends entirely on how your traffic behaves. When work is intermittent — idle much of the time, then spiking — scaling to zero means you pay only for the invocations that happen, and you avoid paying to keep servers warm for the idle majority. That is a real saving, not an accounting trick. When work is steady and high-volume, per-invocation pricing runs against you, and reserved always-on capacity is cheaper for the same throughput. The mistake is assuming serverless is cheaper in general; it is cheaper for spiky work and dearer for constant work, and a workload can cross from one to the other as it grows, which is why the cost model deserves revisiting rather than deciding once.
How serious is the vendor lock-in with serverless, really?+
It is more significant than with containers and less than the fear of it suggests, and the right response is to enter it deliberately rather than to avoid serverless or pretend it away. Serverless functions are wired to a provider’s event sources, triggers and managed services, and that wiring is where the coupling lives; the business logic inside a function is usually portable, but everything connecting it to the platform is not. In practice this means a future migration is a real project rather than a lift-and-shift, and its size depends on how much provider-specific glue you accepted. We treat lock-in as a cost to price in — keeping the core logic separable, being clear about which provider services you are binding to, and choosing that binding where the benefit is worth it — so it is a decision on the record, not a discovery years later.
Are cold starts a real problem or a myth people keep repeating?+
They are real, but whether they are a problem depends entirely on where they land. A cold start is the delay a function pays the first time it runs after being idle, while the platform initialises it — typically from a fraction of a second to a couple of seconds depending on the runtime and the function. For a background job, a scheduled task or an event handler nobody is waiting on, that delay is invisible and irrelevant. For a request a user is actively waiting for, especially on a path that is meant to feel instant, it is a visible stall that shows up unpredictably. Where cold starts matter, they can be reduced with warming or provisioned concurrency, but those keep capacity ready and so erode the scale-to-zero economics that made serverless attractive. The honest way to treat cold starts is to decide up front whether the path can tolerate them, and to keep the latency-critical work off serverless when it cannot.
In this cluster
Decide it with us
An architecture decision that names which parts of your workload belong on serverless and which do not, with the cold-start, lock-in and observability trade-offs stated before you commit rather than discovered in production.
Start the conversation
