Part 8 of 9 · 3 min read
Maintainability
Operability, simplicity and evolvability: why most of a system's cost comes after launch.
Maintainability
Think of a house. Building takes a year. Living in it takes decades. The cost of repairs, cleaning and changes over those decades far exceeds the cost of building. Software is the same: most of its cost is in keeping it running and changing it.
Maintainability has three parts.
Operability
Operability is how easy it is for the team that runs the system to keep it healthy: to watch it, find problems, update it and recover from trouble.
Example: a dashboard that shows the health of every part, and a documented way to restart a stuck process.
Good operability includes clear monitoring, good documentation, sensible defaults, the ability to take one machine out of service without downtime, and predictable behaviour that does not surprise the operators.
Simplicity
Simplicity means a new engineer can understand the system without great effort. A system is complex when its parts are tangled, when the same idea has many names, or when there are special cases everywhere.
Example: a design with clear boundaries, where each part does one job, is simpler than one where every part calls every other.
Complexity slows every future change and makes bugs likelier. The fix is abstraction: hiding messy details behind a clean surface, so that people using a part need not know how it works inside. A programming language hides machine code. A database hides disk layout.
Evolvability
Evolvability is how easy it is to change the system when needs change: new features, new rules, new scale, new technology.
Example: adding a new payment method needs a small change in one place, not changes in twenty.
Requirements always change, so a design that cannot change is a design that will be replaced. Evolvability is closely linked to simplicity: simple systems are easier to change.
Read it as
Reliability is about today's faults. Scalability is about tomorrow's load. Maintainability is about the next five years of people.
A summary of how the three goals later show up as techniques:
| Goal | Techniques met later in this path |
|---|---|
| Reliability | Replication (Level 4), backups, retries, circuit breakers (Level 8), monitoring (Level 9) |
| Scalability | Load balancers (Level 1), caching (Level 3), sharding (Level 4), queues (Level 6) |
| Maintainability | Clear service boundaries, automation, good logs, safe releases |
Check yourself:
- A system works but nobody dares to change it. Which of the three parts of maintainability is missing?
- Why is a simpler design often cheaper in the long run?
Words you will meet
| Word | Plain meaning |
|---|---|
| Reliability | Works correctly even when things go wrong |
| Scalability | Keeps working well as it grows |
| Maintainability | Many people can run and change it over the years |
| Fault | One part going wrong |
| Fault tolerance | Keeps working despite faults |
| MTTF | Average time before a part fails |
| Redundancy | Extra copies that take over when one fails |
| Load parameters | The few numbers that describe the work |
| Fan-out | One request causing many others |
| Throughput | Work finished per unit of time |
| Response time | Time from request to answer |
| Percentile | A threshold that a given share of requests beat |
| SLO | A target for speed or uptime |
| Tail latency amplification | Many calls make slow pages likely |
| Operability | Easy for the run team |
| Simplicity | Easy to understand |
| Evolvability | Easy to change |