Transformation · Playbook

The Simplification Playbook

When you remove a step from a process, the work that step did has to go somewhere. Sometimes the work disappears. Often the work moves to a customer, to a colleague, or into next quarter as rework. This playbook gives you six ideas, a worksheet and a method for telling the difference before you cut anything. Predict how three simplifications turned out before you read on.

Guess first

How did each simplification turn out?

Question 1 of 3 · Tap an answer

A finance team cuts expense approval from five steps to two by dropping manager sign-off on claims under $500. What is the most likely result a year later?

Question 2 of 3 · Tap an answer

A contact centre replaces twelve call scripts with one script for every caller, so that training takes less time. Which number is most likely to rise?

Question 3 of 3 · Tap an answer

A monthly report includes a reconciliation step that nobody on the current team can explain. What should you do first?

Understand it

Six ideas, each answering one question

These ideas come from software engineering, cybernetics and the study of complex systems. Each one answers a question you will face when you simplify a process, a policy, a system or a report.

Brooks, 1986

Essential and accidental complexity

QuestionWhich complexity can be removed at all?

The ideaFred Brooks divided the difficulty of building software into two kinds. Essential complexity belongs to the problem, such as tax rules or what a customer needs. Accidental complexity comes from how we chose to solve the problem: the tools, the handoffs, the workarounds and the history (Brooks, 1986).

Use it toAim every cut at accidental complexity. Essential complexity can be moved or reorganized, but not removed.

Watch forOwners tend to call their own steps essential. Ask what the outcome requires, not what the current system requires.

Tesler

Conservation of complexity

QuestionWhen I remove a step, where does its work go?

The ideaLarry Tesler, who designed software interfaces at Xerox PARC and Apple, argued that every process carries a core of complexity that cannot be removed, only moved between the system and the people who use it. The idea is known as Tesler’s law (Saffer, 2009).

Use it toFor every step you cut, name who does that work afterward. A good simplification moves essential work to whoever can do the work most cheaply, which is often software.

Watch forSelf-service can be a real simplification or a transfer of work onto the customer. Count the customer’s steps as well as your own.

Ashby, 1956

Requisite variety

QuestionHow simple am I allowed to make this?

The ideaW. Ross Ashby showed that a system can only keep control of as many different situations as it has different responses: “only variety can destroy variety” (Ashby, 1956). A process stays in control in one of two ways. The process can reduce the variety that arrives, or the process can increase the variety of its responses.

Use it toBefore you standardize a process, count the kinds of case that reach the process. To simplify, narrow what arrives (a clearer intake form, a narrower scope, saying no to some requests) before you cut the responses.

Watch forA process with fewer responses than the kinds of case it receives does not become simpler. The cases it cannot handle reappear as escalations and workarounds.

Simon, 1962 · Parnas, 1972

Cutting along the seams

QuestionWhere should I divide the problem into pieces?

The ideaHerbert Simon observed that complex systems which last tend to be “nearly decomposable”: they divide into parts with many interactions inside each part and few between parts (Simon, 1962). David Parnas gave the rule for drawing the boundaries: put each decision that is likely to change inside one part, so a change touches one part only (Parnas, 1972).

Use it toGroup the steps and decisions that change together under one owner. Count the handoffs between groups, because each handoff is an interface that someone has to maintain.

Watch forBoundaries drawn along the organization chart rather than along the work can add handoffs. Melvin Conway observed that systems tend to copy the communication structure of the organization that builds them (Conway, 1968).

Practise it: Conway’s Law →
Gall, 1975

Gall’s law

QuestionHow do I build the simpler version without breaking what works?

The ideaJohn Gall wrote that “a complex system that works is invariably found to have evolved from a simple system that worked”. He added that a complex system designed from scratch never works and cannot be patched up to make it work (Gall, 1975).

Use it toReplace a process one thin slice at a time, such as one type of case, one team or one region, from start to finish. Expand the change only after the slice works.

Watch forGall’s law is an observation from experience, not a tested law. Treat Gall’s law as a strong default rather than a proof.

Practise it: The Thin Vertical Slice →
Chesterton, 1929

Chesterton’s fence

QuestionIs it safe to remove this step?

The ideaG. K. Chesterton described a fence across a road. A reformer who can see no use for the fence should not remove it until they have found out why someone built it (Chesterton, 1929).

Use it toFor every step that nobody can explain, find the person or the incident that created the step. Many such steps guard against a problem that no longer exists, and those steps can go.

Watch forThe rule can become an excuse to keep everything. Set a date for the search. If nobody can name a reason by that date, remove the step in a way you can reverse.

Try it on a real process

Sort the steps of one process

Pick an example, or type the steps of a process you know. For each step, answer three questions. The worksheet gives a verdict for each step and a summary for the process.

You predict that 50% of the steps can be removed.

The method

Six steps to simplify something

The steps run in order. Each one uses one or two of the ideas above.

  1. Name the outcome and who receives the outcome

    Write one sentence: this process exists so that a named person or group gets a named result. Judge every step against that sentence. If the team cannot agree on the sentence, stop and settle the disagreement first, because no list of steps can be sorted without the sentence.

    Ask: what does the person at the end of this process need from the process?

  2. Map the process as people do the work

    Walk through the process with the people who do the work, rather than reading the procedure document. Record each step, who does the step, and where the work waits for someone else. In our experience, the gap between the document and the walk-through is where most accidental complexity sits.

    Ask: what happens to a case between the moment it arrives and the moment it is finished?

  3. Sort each step as essential or accidental

    Use the worksheet above. A step is essential when the outcome needs the step. A step is accidental when a tool, a handoff or an old incident created the step (Brooks).

    Ask: would this step exist if we designed the process today, with today’s tools?

  4. Check each step before you cut it

    Put three questions to every step you plan to remove. Where does the step’s work go (Tesler)? Does the step handle unusual cases that will still arrive (Ashby)? Can anyone say why the step exists (Chesterton)?

    Ask: who will do this work after the step is gone, and will that person do the work more cheaply?

  5. Cut along the seams

    Group the steps that change together, and give each group one owner. Then count the handoffs between groups and reduce them, because handoffs are where work waits and where errors enter (Simon and Parnas).

    Ask: if the rules for this case changed tomorrow, how many teams would have to change what they do?

  6. Change one thin slice, then measure

    Choose one type of case and change the process for that case from start to finish. Measure the result against the numbers you recorded in step 2, and expand the change only when the slice works (Gall).

    Ask: what is the smallest change that would show whether the simpler process works?

Measures that show whether a process became simpler

Counting steps is not enough, because a process can lose steps and gain waiting. Lean practitioners use measures like the five below, and none of them needs special software. Measure the people downstream as well as your own team, so that moved work shows up.

MeasureWhat the measure countsWhat a simpler process shows
HandoffsThe number of times a case passes from one person or team to anotherFewer handoffs
Lead timeThe time from a request to the finished resultA shorter lead time
Flow efficiencyThe time someone works on a case, divided by the lead timeA higher share of time spent working rather than waiting
Rework rateThe share of cases sent back to an earlier stepA lower rework rate
Exception rateThe share of cases that leave the standard pathA stable or lower exception rate; a rising rate means the process has too few responses (Ashby)

Where this bites

The same checks in five other places

The ideas apply wherever complexity builds up: in systems, policies, reports, products and organizations.

Application portfolio

Three customer databases after two acquisitions

What to checkOne customer record is essential. Three systems holding that record are accidental. The work of keeping the three in step falls on whoever reconciles them today.

The moveMove one business unit onto the surviving system first, and retire the others only after that unit runs cleanly.

Policies

A travel policy that has grown to thirty pages

What to checkEach clause was probably added after an incident. Find the incident before deleting the clause, and ask whether a single spending limit with discretion would cover the same cases.

The moveReplace many narrow rules with one limit and a named person who decides exceptions. Discretion gives the policy more responses with fewer rules.

Reports

A dashboard with sixty metrics

What to checkAsk which metrics have changed a decision in the last year. The information bottleneck method (Tishby, Pereira and Bialek, 1999) formalizes the same idea: keep the information that predicts the outcome you care about, and compress the rest.

The moveKeep the metrics that changed a decision, and move the rest to a page people can open when they need it.

Practise it: The Chart Chooser →
Products

Removing a feature that few customers use

What to checkThe customers who used the feature still have the need. Without the feature, those customers do the work by hand or call support, so the work has moved rather than disappeared.

The moveCount the support contacts and workarounds after removal, not only the code you no longer maintain.

Software

A module that every change has to touch

What to checkCyclomatic complexity (McCabe, 1976) counts the independent paths through a piece of code. Coupling and cohesion (Stevens, Myers and Constantine, 1974) measure how much the parts depend on each other.

The moveSplit the module so that each decision likely to change sits in one place, then measure whether changes touch fewer files.

Practise it: Monolith vs Microservices →

Go deeper

The formal theory underneath

The six ideas above are the practical ones. The approaches below are the formal work behind “simple”, for readers who want to go further. Most of them need mathematics to apply directly, but each idea is useful as a way of thinking.

ApproachThe ideaUseful forLimit
Minimum description length (Rissanen, 1978)The best explanation gives the shortest total description of the model plus the errors the model still makes. Minimum description length is a formal version of Occam’s razor.Choosing between explanations, and stopping a model that fits every past case from winning by default. The Copernican Switch shows a reframing that shortens a description.Applying the method directly requires statistics.
Kolmogorov complexity (Kolmogorov, 1965)The complexity of an object is the length of the shortest program that produces the object.Defining what “simple” means in principle.Kolmogorov complexity cannot be computed in general.
Information entropy (Shannon, 1948)Entropy measures the average surprise in a message, which sets a lower limit on how far the message can be compressed.Spotting reports that tell the reader only what the reader expected.Entropy measures the quantity of information, not the meaning or relevance.
Cognitive load theory (Sweller, 1988)Working memory is small, so material should cut the load that comes from presentation and keep the load that comes from the subject.Training, documentation and page design.Researchers still debate how to measure each kind of load.
Cynefin (Snowden and Boone, 2007)In clear and complicated situations, analysis finds the answer. In complex situations, cause and effect is visible only afterward, so small experiments work better than analysis.Deciding whether to analyze a process or to run a small experiment on the process.Cynefin helps you make sense of a situation; Cynefin is not a simplification method.
Pareto principleA small share of causes tends to produce a large share of the effect.Deciding which process or which step to simplify first. Technology Mental Models covers the principle.The 80/20 split is a tendency, not a constant.

Use it this week

Simplify one process this month

Pick one process that you touch every week and that frustrates at least two people. Book thirty minutes with the people who do the work, and list the steps together in the worksheet above. Find one step to remove and one step whose tool should change. Remove the first step this month, and measure the handoffs and lead time before and after.

Every step does some work, so simplifying means removing the work nobody needs and deciding who carries the rest.

Simplifying well is one part of thinking clearly about digital work. The Digital Intelligence course builds the rest of that skill one day at a time.

Sources
  • Ashby, W. R. (1956). An Introduction to Cybernetics.
  • Brooks, F. P. (1986). No silver bullet: essence and accident in software engineering. Proceedings of the IFIP Tenth World Computing Conference. Reprinted as “No silver bullet: essence and accidents of software engineering” in Computer, 1987.
  • Chesterton, G. K. (1929). The Thing.
  • Conway, M. E. (1968). How do committees invent? Datamation.
  • Gall, J. (1975). Systemantics: How Systems Work and Especially How They Fail.
  • Kolmogorov, A. N. (1965). Three approaches to the quantitative definition of information. Problems of Information Transmission.
  • McCabe, T. J. (1976). A complexity measure. IEEE Transactions on Software Engineering.
  • Parnas, D. L. (1972). On the criteria to be used in decomposing systems into modules. Communications of the ACM.
  • Rissanen, J. (1978). Modeling by shortest data description. Automatica.
  • Saffer, D. (2009). Designing for Interaction (2nd edition), which includes Tesler’s law of the conservation of complexity.
  • Shannon, C. E. (1948). A mathematical theory of communication. Bell System Technical Journal.
  • Simon, H. A. (1962). The architecture of complexity. Proceedings of the American Philosophical Society.
  • Snowden, D. J. and Boone, M. E. (2007). A leader’s framework for decision making. Harvard Business Review, November 2007.
  • Stevens, W. P., Myers, G. J. and Constantine, L. L. (1974). Structured design. IBM Systems Journal.
  • Sweller, J. (1988). Cognitive load during problem solving. Cognitive Science.
  • Tishby, N., Pereira, F. C. and Bialek, W. (1999). The information bottleneck method. Proceedings of the 37th Allerton Conference.