Skip to main content

How to Resolve Technical Disagreements: Find the Layer Before You Argue

Design reviews loop because people argue options while disagreeing about facts, forecasts, weights or costs. One question tells you which, and each has its own fix.

Updated 11 min readMarkdown
How to Resolve Technical Disagreements: Find the Layer Before You Argue

If a design discussion produces the same three arguments in two different meetings, the team is not stuck on the decision. It's stuck one layer below it.

That's the whole idea of this post. The rest is how to find the layer quickly and what to do once you've found it.

The symptom: the spike that settled nothing

Here's a pattern most engineers will recognize. A team is choosing between Kafka and the Postgres-backed job queue it already runs for order events. Priya wants Kafka. Marcus wants Postgres. After two meetings, everyone agrees to "let the data decide" and runs a spike.

The spike shows Postgres handles current load comfortably. Marcus considers the matter closed. Priya says that was never the question. The third meeting sounds exactly like the first.

Both of them are right, and that's the problem:

  • Priya is arguing that order events will soon have several consumers (analytics, fraud) and that a replayable log handles that cleanly while a job queue doesn't. Volume is rising and she'd rather migrate early than under pressure.
  • Marcus is arguing that Kafka is one more system to run, monitor, upgrade and get paged for, that today's load fits in Postgres, and that the replay need is hypothetical.

Every claim on both sides is true. They're scoring the same options on different scoresheets.

Two cards: what the spike answered (today's load, read speed, prototype runs, all yes) versus what they were arguing (future growth, replay vs simplicity, who gets paged)

The four layers under every technical decision

Any option anyone proposes rests on four kinds of belief:

Layer The question Example from the Kafka debate Can you measure it today?
Facts What is true right now? Can Postgres handle today's peak? Yes
Forecasts What will be true later? Will volume grow 10× this year? Will a second team need the events? No
Weights What matters most? Shipping analytics by March vs adding no new on-call surface No, it's a choice
Costs Who pays if it goes wrong? Who gets paged when the broker falls over? No, it's an allocation

A spike, benchmark or prototype only works on the first row. Experienced engineers rarely disagree on that row, which is why the spike came back and changed nothing. Priya's case was a forecast plus a weight. Marcus's was a weight plus a cost.

Evidence aimed at the wrong layer doesn't just fail to persuade. It tells the other person their real concern was skipped, so they restate it harder.

There's a well-known argument for why more meetings don't help. In "Why do humans reason?" (Behavioral and Brain Sciences, 2011), Hugo Mercier and Dan Sperber propose that reasoning evolved mainly to produce and evaluate arguments meant to persuade, and that on our own we're skilled at finding support for conclusions we already hold. Under that view, each extra round gives both sides better arguments rather than bringing them closer. The same authors argue people are much better at evaluating others' arguments than their own, which is why the fix is to get both people examining one shared claim.

The one-question diagnostic

Ask each person, separately, and write the answers where everyone can see them:

"What would change your mind?"

The shape of the answer names the layer:

  • A measurable result ("show me Postgres falling over at today's peak") → Facts.
  • A future event ("if volume stayed flat for a year, I'd drop it") → Forecasts.
  • "Nothing, I just think fewer moving parts matters more" → Weights. This is not stubbornness. It's the most useful answer you'll get, because it tells you more evidence won't help.
  • "I'd be fine if I weren't carrying the pager" → Costs.

The Center for Applied Rationality's double crux technique calls the target a crux: a belief that, if it changed, would change your conclusion. This question is a fast way to surface one in a design review.

The Layer Check: Facts, measure it. Forecasts, set a tripwire. Weights, owner decides. Costs, move or price it.

The fix for each layer

Facts: measure, but write the verdict first

Before a spike, each person writes the result that would flip them: "If Postgres p95 stays under 200 ms at 2× today's peak, I'll drop Kafka." If nobody can name a result, cancel the spike. The disagreement isn't on this layer.

Forecasts: "what would have to be true?" plus a tripwire

Roger Martin calls "What would have to be true?" the most valuable question in strategy, and notes that stripping the data out lets people agree on the logic quickly. Run it for each option:

  • Kafka is right if volume grows sharply or a second consumer arrives soon.
  • Postgres is right if neither happens within the year.

The debate is now one forecast. You can't settle it today, so pick an observable signal that would show it going wrong (sustained queue lag, a second team asking for the events). That's the tripwire: the agreed condition for reopening the decision.

Weights: escalate the layer, not the options

No amount of analysis resolves a priority conflict. It's a decision for whoever owns the outcome. Don't escalate "Kafka or Postgres?" Escalate the layer:

"We agree on current load and on the growth risk. We disagree on whether shipping analytics by March matters more than adding no new on-call surface this quarter. That's your call."

A product or engineering lead can answer that quickly, because ranking priorities is their job.

Costs: move the cost or price it

Resistance to a new system often comes from whoever will be paged for it. That's a real, unpriced cost. Move it (the proposer takes primary on-call for the first quarter) or price it (runbooks, alerts, training budgeted before launch). If the objection softens once the cost moves, you've confirmed which layer you were on.

Anti-patterns that feel fair

Move Why it backfires
Split the difference (Kafka for some events, Postgres for others) You run both systems and get the full benefit of neither. Compromise works on numbers, not on weights.
Vote Counts preferences, hides layers. The losing side keeps its reasons and brings them back at the next incident.
Defer to experience ("I've seen this fail") That's a forecast from a different system. Ask: "What was different about that system?" Both possible answers are useful.
Schedule another meeting Without a layer, another round mostly produces better-prepared positions.

Disagree and commit, with a receipt

Jeff Bezos popularized "disagree and commit" in his 2016 shareholder letter. It's good advice that leaves out commit to what, and until when? An open-ended commitment quietly becomes permanent, and the dissenting view either vanishes or resurfaces as sniping.

Michael Nygard's 2011 Architecture Decision Record captures context, decision and consequences. Keep it, and add the fields that turn a lost argument into a checkable prediction:

# 0042: Order events stay on the Postgres job queue

## Status
Accepted

## Context
Order events currently have one consumer. Analytics and fraud may need them.

## Decision
Keep the Postgres-backed job queue. Do not introduce Kafka this year.

## We disagreed on
Forecasts: whether order volume or the number of consumers will outgrow Postgres within 12 months.
(Facts were not in dispute: the spike showed current peak load is comfortable.)

## The bet
Volume stays under 3x today's peak and no second consumer needs replay for 12 months.

## Tripwire (revisit when any is true)
- p95 queue lag above 30 s for 7 consecutive days
- A second team requests replayable access to order events

## Dissent
Priya. Proven right if a tripwire fires before Q3.

## Consequences
One fewer system to operate. If the tripwire fires, migration happens under more load than today.

(Values are illustrative. Use your own thresholds.)

The Decision Note: Decision, We disagreed on, The bet, Tripwire, Dissent

Two effects: the dissenter now owns a prediction instead of a grudge, and reopening the decision requires the tripwire to fire, not a bad week. For cheaply reversible decisions, skip most of this. Pick, set a tripwire, move on. Save the full check for one-way-door decisions.

Common debates and the question to ask first

Before arguing, ask which layer you're on. These are prompts to test, not verdicts:

Debate Ask first
Monolith vs microservices "Are we disagreeing about today's pain or about team size in 18 months?"
ORM vs raw SQL "Is this about a measured performance problem, or about who maintains the queries?"
REST vs GraphQL "Which client needs are real today and which are forecasts?"
Rewrite vs refactor "What would have to be true for the rewrite to finish before the old system's next big change?"
Adopt a new framework "Who carries upgrades and on-call for it, and have we priced that?"

Key Takeaways

  • A debate that repeats the same arguments is stuck one layer below the options.
  • Four layers: facts (measure), forecasts (what would have to be true + tripwire), weights (owner decides), costs (move or price).
  • Ask everyone "What would change your mind?" The shape of the answer names the layer.
  • Spikes only resolve facts. Before running one, have each person write the result that would flip them.
  • Escalate the layer, not the options.
  • Splitting the difference, voting and deferring to experience feel fair and usually make it worse.
  • Close with a decision record that names the bet, the tripwire and the dissent.

FAQ

How do you resolve a technical disagreement on a software team?

Identify which layer the disagreement is on before arguing options. Ask each person what would change their mind. Measurable answers mean a fact dispute (run a test), future-event answers mean a forecast dispute (agree on a tripwire), "nothing" means a priority dispute (the outcome owner decides), and answers about who carries the work mean a cost dispute (move or price the cost).

Why do architecture debates go in circles?

Because people argue about options while disagreeing about something underneath them: a forecast, a priority or who pays the downside. Evidence offered at the option or fact level doesn't touch those, so each side feels unheard and restates its case.

Should you run a spike or prototype to settle a design debate?

Only if the disagreement is about a measurable fact. Have each person write down, before the spike, what result would change their mind. If no one can, the disagreement is about forecasts, weights or costs, and the spike won't settle it.

What does "disagree and commit" mean, and how do you do it well?

It means supporting a decision you argued against once it's made. It works best with a written condition for revisiting: record the bet, a tripwire that would show it failing, and the name of the person who disagreed, so commitment isn't open-ended.

What should an architecture decision record (ADR) include beyond the basics?

Nygard's format covers context, decision and consequences. For contested decisions, add the layer you disagreed on, the forecast you're betting on, a tripwire for revisiting, and the dissent. Those fields make the decision checkable later.

Who should make the final call when engineers disagree on priorities?

Whoever owns the outcome, usually a product or engineering lead. Escalate the specific priority conflict ("speed by March vs no new on-call surface"), not the technical options, so they can decide quickly on the thing that is actually theirs to decide.

Get one of these in your inbox each week: subscribe to Simply Explained on Substack.

The bottom line

The argument was never Kafka versus Postgres. It was a disagreement about next year, and nobody in the room could see next year. Once the team named that, they wrote down the bet, agreed on the tripwire and moved on.

You don't end a technical debate by winning it. You end it by finding out what it was about.

Adam Jaber is a software engineer who writes Simply Explained: complex topics, made simple. No jargon, no hype.

About the author

  • I'm a senior software engineer. I write Simply Explained, a plain-English breakdown of how AI and software actually work, and the quiet ways they break: AI fixes that hide bugs, agents that pick the wrong tool, health checks that take down healthy servers. One symptom, one analogy, one fix per piece. New here? Start with the pinned Start Here guide, or get one breakdown a week by email.

No comments yet. Be the first to comment.

More from this blog