CSE Roadmap

Core tier · about 3 hours · 9 parts

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