Architecture & practice

the meeting spent five minutes on the data retention policy and thirty-five on the button label.

Bikeshedding

you shipped the quick version to make the date, wrote down what you skipped, and paid for it every sprint after.

Technical debt

the design covered what happens when it works and the review found nothing about what happens when the vendor is down.

Happy path thinking

you changed the order of a JSON response and a customer's integration broke, and nowhere did you promise an order.

Hyrum's law

you deleted the odd-looking retry, and a week later found out which flaky vendor it was for.

Chesterton's fence

you built the plugin system for the second provider, and two years later there is still only one provider.

YAGNI

you changed one module and three tests in a directory you had never opened went red.

Coupling

the code for one job is spread over four files, and each of those files also does three unrelated jobs.

Cohesion

you wanted to change the retry policy and had to read a HTML template to find where it was set.

Separation of concerns

the function reads like a sentence for three lines and then drops into byte offsets.

Level of abstraction

the ORM hid the SQL right up until you had to read the query plan to fix a timeout.

Leaky abstraction

the rules really are that fiddly, because tax law is that fiddly, and no rewrite will make them simpler.

Essential complexity

half the file is there to work around a framework decision that has nothing to do with the feature.

Accidental complexity

the design handles ten thousand requests a second and the product has forty users.

Over-engineering

you asked where the pricing logic lives and were told it depends which of five places you mean.

Big ball of mud

everything ships together, so one bad line in someone else's feature blocks your release.

Monolith

you kept the single deployable and made a module boundary something the build fails on when crossed.

Modular monolith

the service you own deploys on its own schedule and you have never waited for another team's release.

Microservice

you split it into six services and still have to deploy all six together, in the right order.

Distributed monolith

'customer' means one thing to billing and something else to support, and the shared table forces one of them to be wrong.

Bounded context

one region went down and you found out which of your services quietly lived only in that region.

Failure domain

you ask how much of the product breaks if this one component dies, and design so the answer is not "all of it".

Blast radiusBackend

you trace the dependency graph and find one component whose failure takes everything else down with it.

Single point of failureBackend

you picked the customer-facing URL scheme, and two years of links mean it is never changing.

One-way door

you argued for a week about a library you could have swapped out in an afternoon.

Two-way door

you shipped it because you knew exactly how you would undo it, not because you were sure.

Reversibility

someone asked whether this needed a written decision, and the answer was whether it would be expensive to change later.

Architectural significance

you presented the design and spent forty minutes on a question you had not thought to ask yourself.

Design review

you wrote up the plan and left it open for a week so people could argue in the margins before you built anything.

Request for comments

you asked why the queue was chosen and someone found a one-page file in the repository from 2023.

Architecture decision record

everyone agrees it should be replaced, and everyone also agrees it is the only thing that knows the pricing rules.

Legacy system

you put a router in front and moved one endpoint at a time until the old service had no traffic left.

Strangler fig

you decided to start again, and the old system kept receiving feature requests the whole time.

Rewrite

the replacement was blocked for two months on a report that four people run once a year.

Feature parity

the rewrite is going to fix every compromise in version one, all at once, and it is nine months late.

Second-system effect

the system has four services and the company has four teams, and nobody planned that.

Conway's law

the team owns nine services and can explain four of them.

Cognitive load

one person was on holiday and the release could not go out until they got back.

Bus factor

you opened a pull request against another team's repository and it sat there for eleven days.

Code ownership

you were asked for a date before anyone had opened the vendor's documentation, and gave one.

Cone of uncertainty

you estimated the happy path, which is the only version of the work you pictured.

Planning fallacy

the team sized it a five, and someone in a status meeting asked how many days a five is.

Story point

you sorted twelve ideas into small, medium and large in twenty minutes, which was all the decision needed.

T-shirt sizing

the request was made in March and reached customers in June, and the coding took four days.

Lead time

the work took four days once someone started it, and it had been sitting in the backlog since March.

Cycle time

you were told to finish one of the four things you had started before picking up a fifth.

Work-in-progress limit

each addition was reasonable on its own and the project is four months longer than it was in January.

Scope creep

you sat down a week later with the timeline and worked out why the wrong dashboard was the obvious one to check.

Incident review

you write up what happened focusing on why the system allowed it, not on who typed the command.

Blameless postmortemBackend

you asked why five times and ended up at a deploy process nobody had questioned in two years.

Five whys

the deploy triggered it, and the missing alert, the stale runbook and the one-person rotation all had to be true as well.

Contributing factor

the migration has taken eight months, so the argument for continuing was that it has taken eight months.

Sunk cost fallacy

you believed it was the cache and read the logs looking for the cache, and found something.

Confirmation bias

the team was measured on tickets closed, and the tickets got smaller.

Goodhart's law

the room had agreed until the director said what they preferred, and then everyone had a new opinion.

HiPPO

you argued a position firmly, someone produced a number, and you changed your mind in the same meeting.

Strong opinions, weakly held

you argued hard against it, lost, and then did the work properly instead of relitigating in every standup.

Disagree and commit