Techbanq

Cloud · SRE

Reliability needs a number before it needs heroes

Without an agreed target, reliability is an argument nobody can win: engineers say a release is risky, the business says ship it, and the truth only arrives as an outage. Site reliability engineering gives the question a number — a service-level objective and an error budget the business signs off on — so whether the next change is safe to ship is a measurement, not a standoff, and on-call is a rota rather than a burnout.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Operators monitoring process screens in an industrial control room
  1. 01

    Market

    Saudi Arabia

  2. 02

    Written for

    CTO

  3. 03

    Decision

    Turn reliability from heroics into a measured engineering practice

  4. 04

    Languages

    EN · AR

Information security for software delivery

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The error budget

How an error budget turns a reliability argument into a decision

An error budget is the amount of unreliability the business has agreed it can tolerate. It converts a subjective standoff into a balance that either has room for the next release or does not.

A flow: agree a service-level objective, spend the error budget on change, watch it deplete through incidents, and let the remaining budget govern whether the next release ships — with a branch for revisiting the objective when the budget is always exhausted.

  1. 01

    Agree the objective

    The business and engineering set a service-level objective from what users feel, and the budget is the failure that objective permits.

  2. 02

    Spend it on change

    Every release consumes some budget through the risk it carries. While budget remains, teams ship freely.

  3. 03

    Watch it deplete

    Incidents and errors draw the budget down. The balance is visible to everyone, so nobody argues about whether things are getting worse.

  4. 04

    Let it govern the release

    When the budget is spent, the next release waits and reliability work takes priority — automatically, by the rule agreed in advance.

Always available

When the objective itself is wrong

A budget spent every month says the objective is too strict for how the system is built, or the system is too fragile for the objective. That is a signal to revisit the number with the business, not to quietly ignore it — the budget is only useful if breaching it changes something.

Why uptime is the wrong target

The objective has to measure what the user feels, not what the dashboard shows

A common mistake is to set the reliability target on infrastructure uptime — the servers were up 99.9% of the time — while users experienced something worse, because a slow checkout or a failing search is a failure the user feels even when the server is technically running. A service-level objective is worth having only if it measures the thing a user actually cares about: did the request they made succeed, quickly enough to be usable. That is harder to measure than uptime, and it is the only measurement that governs anything real.

Getting the objective right is why SRE is engineering rather than monitoring. It means instrumenting the system to see what the user sees, choosing objectives the business will actually stand behind when a release is at stake, and then building the automation, the runbooks and the on-call practice around them. Reliability that depends on a few heroes staying late is not a practice; it is a debt that comes due as attrition. The work is to make the system and the process reliable, so no single person is the reason it stays up.

An illustrative engagement

A team shipping fast and firefighting every launch

Typical engagement, not a named client

A product team releases often and each release brings a scramble: something breaks, the same two engineers are paged at night, and the business and engineering argue after every incident about whether they are moving too fast. There is no agreed definition of stable enough, so every release is relitigated and on-call is wearing people out.

  1. 01Define service-level objectives from the requests users actually make, and derive an error budget the business agrees to in writing.
  2. 02Make the budget the rule for shipping: while it has room, release freely; when it is spent, reliability work takes priority automatically.
  3. 03Rebuild on-call around runbooks and blameless review, so incidents produce fixes and fewer future pages rather than blame and fatigue.

The argument after each incident is replaced by a shared number everyone can see. Releases that fit the budget ship without debate, the ones that do not wait by an agreed rule, and on-call stops depending on the same two people staying up. Reliability becomes a property of the system and the process rather than of individual endurance.

Our role

What we engineer into the system and what your on-call owns

  1. 01

    Objectives from the user, not the dashboard

    We instrument the system to measure what users actually experience and set objectives the business will stand behind, because an objective nobody defends when a release is at stake governs nothing.

  2. 02

    A budget the business owns

    We turn the objective into an error budget and agree the rule it enforces on releases, so the trade between speed and stability is decided once, in the open, rather than re-fought after every incident.

  3. 03

    An on-call people can sustain

    We build the runbooks, automation and blameless review that make on-call a rota rather than a burnout, and leave the practice with your team rather than becoming the reliability it depends on.

How much reliability the business will pay for, in engineering effort and slower releases, is a decision that stays with you; we translate that decision into objectives, an error budget and an on-call practice your team runs, so stability is engineered rather than endured.

Common questions

What buyers ask

What exactly is an error budget, and who decides its size?+

An error budget is the amount of unreliability you have decided is acceptable over a period — the gap between a perfect service and the service-level objective you set. If your objective says a request should succeed 99.9% of the time, the remaining 0.1% is the budget you are allowed to spend on the risk of change. The business decides its size, not engineering alone, because the size is a commercial trade: a stricter objective costs slower releases and more reliability work, and a looser one buys speed at the price of more visible failure. The value of agreeing it is that whether to ship the next release stops being an opinion and becomes a balance everyone can read.

Can you just promise us a specific uptime figure?+

No, and a supplier who does is selling a number they cannot control. Reliability is a property of how the system is built, how change is managed and how much the business is willing to invest in it — not something a consultant can guarantee from outside. What we can do is help you set an objective that measures what your users feel, agree the error budget that objective implies, and engineer the system and the on-call practice to hold it. A promised figure with no budget behind it is a slogan; an objective the business has agreed and the system is built to meet is a commitment you can actually keep.

Our on-call is burning people out. Does SRE add more of it?+

The opposite, if it is done properly. Burnout on-call is usually the symptom of a system that is fragile and a process that has no way to make it less so — the same people are paged repeatedly for problems that are never engineered out. SRE treats the pages as data: each incident feeds a blameless review that produces a fix and a runbook, so the same failure does not wake someone twice. The error budget also caps how much instability the system is allowed to carry, which limits the flow of incidents at the source. More on-call is a sign reliability is being bought with people; the aim is to buy it with engineering instead.

Next step

Scope it with us

A reliability engagement that leaves you with agreed objectives, an error budget the business owns, and an on-call your engineers can sustain, so stability is a practice rather than a run of good luck.