The architecture
How redundancy, failover and isolation remove the single point of failure
The inputs are the techniques that each remove one way a single component can take everything down. The architecture is where they combine into a system that survives losing a part.
Four redundancy techniques — redundant instances, automatic failover, multi-zone deployment, externalised state — converging into an architecture with no single point of failure, producing survival of a component loss, maintenance without downtime, and headroom to lose a zone.
Redundant instances
More than one of every component on the request path, so losing one is a degradation, not a stop.
Automatic failover
A tested switch to the healthy copy in seconds, because a manual failover during an incident is another way to be down.
Multi-zone deployment
Copies spread across independent zones, so a whole zone failing does not take the service with it.
State externalised from compute
Data held in a redundant store rather than on the instance, so a service can be replaced without losing what it kept.
What we do
An architecture with no single point of failure
The techniques combined so that every component on the critical path has an alternative, and no one failure has a path to taking the whole service down.
One component can fail without an outage
The service degrades and recovers instead of stopping.
Maintenance without downtime
A node is taken out, updated and returned while its copies carry the load.
Headroom to lose a zone
Capacity planned so the survivors absorb the traffic of a failed zone.
Availability is not one strong component; it is the absence of a component that can fail alone.
Bought versus built
The load balancer that moved the outage instead of removing it
A common way to misunderstand high availability is to treat it as a product: buy a load balancer, put two web servers behind it, and call the system highly available. But if those two web servers both talk to a single database, the outage has not been removed — it has been moved to the database, which is now the one component whose failure stops everything. Availability is not conferred by any one device; it is a property of the whole path a request takes, and it is only as good as the least redundant thing on that path. A system is available when nothing on the critical path can fail alone, and finding the thing that still can is most of the work.
This is why high availability cannot be bought as a line item. A managed service can make one tier redundant, but the availability of your system is decided by how all its parts fit together — where state lives, whether a queue has a backup, whether a shared cache is a hidden dependency, whether the failover has ever actually been triggered. The engineering is unglamorous: trace the path, name each point that can fail alone, and decide, component by component, which are worth the cost of redundancy. Some are; some are not. The value is in knowing which, before an outage decides for you.
What survival requires
The conditions a system must meet before it can survive losing a part
High availability is not one setting but a set of properties the whole system has to hold at once. These are the conditions that, together, mean no single failure is an outage.
No single instance on the request path
Every component a request touches has a running peer, so there is no one box whose loss is total.
What it makes possible: A component failure that is felt as a dip, not a stop.
State held outside the compute
Data lives in a redundant store, so an instance carries no unique state that dies with it.
What it makes possible: A service that can be replaced without losing what it held.
Failover that is automatic and tested
The switch to a healthy copy happens without a human and has been triggered on purpose to prove it works.
What it makes possible: Recovery measured in seconds, not in how fast someone reacts.
Capacity to absorb a lost node or zone
The survivors are provisioned to carry the failed part’s traffic, so failover does not simply overload the next component.
What it makes possible: A failure that stays contained instead of cascading.
Our role
What we design out of the architecture and what you decide is worth the cost
- 01
The failure analysis first
We trace the request path and name every component that can fail alone, because you cannot design out a single point of failure you have not found, and the hidden ones — a shared cache, an unreplicated queue — are the ones that cause the outage.
- 02
Redundancy where it earns its cost
We design the redundancy, failover and isolation each system actually needs, rather than applying the highest tier everywhere, because availability has a real cost and not every system is worth the same amount of it.
- 03
A tested architecture your team owns
We trigger the failover to prove it works and hand over an architecture your team understands, so availability is a demonstrated property rather than an assumption printed on a diagram.
Which systems justify the cost of high availability, and how much downtime each can tolerate, are yours to weigh; we find the single points of failure, design out the ones you choose to remove, and prove the failover works before you depend on it.
Common questions
What buyers ask
Isn’t high availability something we get automatically by using a managed cloud service?+
A managed service can make one part of your system redundant, but it does not make your whole system highly available, because availability is a property of how all the parts fit together. You can run a managed, multi-zone database and still have an outage because a single message queue, a shared cache, or one stateful service in front of it can fail alone. The cloud gives you the building blocks for redundancy; it does not decide where you have left a single point of failure. That is an architecture question about your specific system, and it is answered by tracing the request path and finding the component that everything else still depends on, not by ticking a box on a managed service.
What exactly is a single point of failure, and how do you find ours?+
A single point of failure is any component on the path a request takes that has no alternative — if it stops, everything that depends on it stops with it, and there is no second copy to carry on. The obvious ones, like a lone web server, are easy to spot; the dangerous ones are hidden — a shared cache every service quietly relies on, a message queue with no backup, a database that is redundant for storage but not for the primary that accepts writes. We find them by tracing the full request path through your system and asking of each component: if this failed right now, what would still work? The ones where the answer is “nothing” are the single points of failure, and naming them is the step that has to come before designing any of them out.
How much availability is actually worth paying for?+
Not the same amount for every system, which is the point most availability conversations miss. Each additional level of availability costs more — more redundancy, more zones, more capacity held in reserve — and the value of it depends entirely on what an outage of that specific system costs the business. A payment path that loses revenue every minute it is down justifies a high tier; an internal reporting tool that can be offline for an afternoon does not, and paying for the highest availability everywhere wastes money on systems that do not need it. The right answer comes from pairing each system with the cost of its downtime, then buying availability where that cost is high and deliberately not buying it where the cost is low. We would rather help you make that trade explicitly than apply one tier across an estate that does not need it.
In this cluster
Review it with us
An availability review that traces the request path, names each single point of failure, and states the cost of designing it out — so you decide which systems are worth the redundancy and which are not.
Start the conversation
