Contact Us
Contact Us
DevOps & Platforms

Observability and SRE for Small Teams: Fewer Incidents Without a 24/7 Rota

How a lean engineering team can use observability, service level objectives and a few incident habits to cut outages without running a 24/7 on-call rota.

JRC Software Team
7 min read
Observability and SRE for Small Teams: Fewer Incidents Without a 24/7 Rota

Most small SaaS teams already have an alerting system. It's called the support inbox. Customers notice the outage, someone emails, and a founder's phone lights up at 7am.

Where proper alerts do exist, they usually fire so often that the whole team has muted the Slack channel. The product has paying customers, the engineering team is five or six people, and nobody is formally on call.

Good observability and a handful of borrowed SRE practices fix most of this, without hiring a reliability team or running a 24/7 rota. The trick is to measure what users actually experience, page a human only when a human is needed, and learn something from every incident.

Reliability by headcount isn't an option

Big companies solve on-call with people. Google's SRE book chapter on being on-call puts the minimum for a single-site on-call team at eight engineers, or six per site for a team split across two sites. Few Australian scale-ups can staff that, and they shouldn't try.

Meanwhile, change volume keeps rising. Google's announcement of the 2025 DORA report says 90% of respondents use AI at work, and that AI adoption still has a negative relationship with software delivery stability. More changes, shipped faster by fewer people. You need better signals, not more people watching dashboards.

Most reliability practice is about focus rather than scale, though. A small team that alerts on the right things and limits risky changes can run a stable service where on-call is a normal working-hours job plus a light out-of-hours safety net.

Observability basics: measure what users feel

OpenTelemetry's observability primer describes observability as being able to understand a system from the outside by asking questions about it, without knowing its inner workings. In practice your services emit three kinds of telemetry: logs, metrics and traces.

For a small team, start with the four golden signals from Google's monitoring chapter:

SignalWhat it tells youExample measure
LatencyHow long requests take (track failed requests separately)95th percentile API response time
TrafficHow much demand the system is handlingRequests per second, checkouts per minute
ErrorsThe rate of failing requestsShare of HTTP 5xx responses
SaturationHow full the most constrained resource isDatabase connections, CPU, queue depth

Instrument these for each user-facing service first. The latency note matters: if you filter errors out of your latency numbers, a flood of fast 500s can make the service look healthier than it is.

Use OpenTelemetry where you can so you're not locked into one vendor. Most languages have auto-instrumentation that covers HTTP and database calls with very little code. Add structured JSON logs that carry the trace ID, so you can jump from a slow trace straight to the log lines for that request.

Page on symptoms, not causes

Google's monitoring chapter draws a line that changes on-call for small teams. Symptoms are what users experience: errors, slow pages, failed checkouts. Causes are the reasons underneath: high CPU, a full disk, a slow query. Page people on symptoms. Keep cause-based signals on dashboards for debugging.

The chapter's rule is blunt: "Every page should be actionable." Run each existing alert through these questions before you keep it:

  1. Is a user affected now, or about to be?
  2. Does it need a human, rather than an automatic restart or retry?
  3. Does the person paged know what to do, with a linked runbook?
  4. Has it fired falsely in the past month? Then fix it or delete it.
  5. Could it wait until business hours? Then make it a ticket, not a page.

A pattern we see often: a big share of existing alerts get deleted or downgraded after this exercise. "CPU above 80% for five minutes" is the classic. Fewer, better alerts make it realistic for one person to carry an out-of-hours phone without burning out.

SRE practices that scale down: SLOs and error budgets

A service level objective (SLO) is a target for a service level indicator, such as "99.9% of checkout requests succeed over 28 days". Google's SLO chapter gives advice that suits small teams: pick just enough SLOs to cover what matters, don't simply adopt today's performance as the target, and never insist on 100%.

The gap between your SLO and 100% is the error budget. Google's example error budget policy shows the arithmetic: a 99.9% SLO over 1,000,000 requests in four weeks allows 1,000 errors. Once the budget is spent, that policy halts changes other than P0 issues and security fixes until the service is back within its SLO. It also requires a postmortem when a single incident eats more than 20% of the four-week budget.

For a lean team we suggest a lighter version:

  • Two or three SLOs for your most important user journeys, such as sign-in and checkout.
  • Alerts on how fast the error budget is burning, not on every individual error. A fast burn pages someone; a slow burn opens a ticket.
  • A written rule for what happens when the budget runs out, agreed with product owners before it happens.

That gives product and engineering a shared, numeric way to decide when to slow down and fix reliability, instead of arguing about it mid-incident.

DORA metrics: delivery and stability side by side

Observability tells you how the system behaves. DORA's software delivery metrics tell you how your delivery process behaves. DORA now describes five metrics in two groups:

GroupMetricWhat it measures
ThroughputChange lead timeTime from commit to running in production
ThroughputDeployment frequencyHow often you deploy
ThroughputFailed deployment recovery timeTime to recover from a deployment that needs immediate intervention
InstabilityChange fail rateShare of deployments needing a rollback or hotfix
InstabilityDeployment rework rateShare of deployments that are unplanned and caused by a production incident

You don't need a commercial tool to start. Most of these come straight out of version control, the pipeline and an incident log, even if that log is a spreadsheet. Review them monthly. If change fail rate climbs, look at test coverage and batch size before blaming anyone. Adopting AI coding agents? Our guide to AI coding agents CI/CD covers the pipeline guardrails that keep these numbers healthy.

Incident habits that stop repeat outages

Habits beat tools here. These are the ones that make the most difference:

  • Agree incident triggers in advance. Google's postmortem chapter lists triggers such as user-visible downtime beyond a threshold, data loss of any kind, on-call intervention like a rollback, and monitoring failures where someone found the problem by hand.
  • Write blameless postmortems. Focus on contributing causes, not people, so engineers raise problems early.
  • Close the action items. A postmortem without a finished fix is just a story.
  • Keep runbooks next to alerts. Every page links to the steps to diagnose and mitigate.
  • Make rollback the first move. Google's error budget policy notes that changes cause roughly 70% of outages, so reverting the last deployment is often the fastest fix.

How JRC Software helps small teams improve observability

We start with a reliability review. In the first week we read your current alert rules and how often each one fired, look at the deployment process, and go through your last few incidents and how they were found. We map the two or three user journeys that matter most and show you where you're blind and where you're noisy.

Then we set up the foundations with your team: OpenTelemetry instrumentation, golden signal dashboards, two or three SLOs with burn-rate alerts, a pruned alert list with runbooks, and a simple monthly DORA report. We'll help you design on-call that fits your size, often business-hours ownership plus one narrow out-of-hours alert for the journey that really can't wait.

Please don't buy an observability platform before you know what you want to measure, don't page on infrastructure metrics, and don't set an SLO you have no intention of acting on. These practices fit naturally into a wider platform, as covered in platform engineering vs DevOps. More on our platform engineering and DevOps services.

If your customers find outages before you do, book a reliability review and we'll help you build observability a small team can actually run.

Frequently asked questions

What is the difference between monitoring and observability?

Monitoring checks for conditions you already know about, such as high CPU or an endpoint returning errors. Observability is the broader ability to work out why a system behaves as it does by asking new questions of its logs, metrics and traces. Monitoring tells you something's wrong; good observability helps you find what and why, including failures nobody predicted.

Can a small team practise SRE without a dedicated SRE team?

Yes. The most useful SRE practices scale down well: a few service level objectives for key user journeys, alerts only on user-facing symptoms, error budgets that guide release decisions, and blameless postmortems. None of these need dedicated SRE roles. The aim is shared ownership of reliability by the engineers who build the product.

Which DORA metrics should a small team track first?

Start with change lead time, deployment frequency and change fail rate, because you can read them from version control and the pipeline with little effort. Add failed deployment recovery time once incidents are logged consistently. Review them monthly as a team, look at trends rather than single values, and use them to guide improvements, never to compare individuals.

Do we need a 24/7 on-call rota?

Usually not. Google's SRE book puts the minimum for a sustainable single-site on-call team at eight engineers, which most small teams don't have. Instead, page only on urgent, user-facing symptoms, agree SLOs with the business, and keep a narrow out-of-hours escalation for critical journeys. Many products run reliably this way.

DevOps & Platforms

Book a reliability review

Tell us where you're stuck and we'll come back with practical next steps.

Get in touch

Sources