Explaining Technical Concepts to Non-Technical Audiences Questions

Direct answer

The core move isn't picking a clever analogy, it's figuring out what decision or worry the stakeholder actually has before you start explaining, then building the explanation to answer that, and checking as you go whether it landed. Below is a caching example: what I chose to include, the analogy I used, how I confirmed it landed, and what happened.

Adapting depth without condescension

• Find out what they need to DECIDE, not just what they need to KNOW. A stakeholder rarely needs to understand caching itself, they need to decide whether to approve a change, a budget, or a timeline; build the explanation around that decision.
• Pick one analogy tied to something they already manage, inventory, a filing system, a pantry, and use it consistently rather than switching metaphors mid-conversation, which confuses even when each individual metaphor is fine on its own.
• Check understanding by asking them to restate the trade-off in their own words or apply it to a hypothetical ("if we changed X, what do you think happens to Y"), never by asking "does that make sense," which invites a polite yes regardless of whether it landed.
• Build the explanation step by step from what they already know rather than reaching for a named technique or framework to describe what you're doing; naming the technique adds nothing for the listener and mostly serves the explainer.

Worked example

Situation: our product team wanted faster page loads, and I needed the VP of Product and a finance manager, neither with an engineering background, to approve adding a caching layer.

Task: get them to understand the trade-off, faster pages, at the cost of occasionally showing slightly outdated data, well enough to make an informed approval decision, not just rubber-stamp it.

Action: I opened with the decision they needed to make, not the technology: "we can make pages load faster by keeping a copy of frequently requested information close by; the trade-off is that copy can be a few seconds out of date." I used a pantry analogy, keeping snacks nearby instead of driving to the store every time, and periodically checking the pantry is still fresh, consistently through the conversation. I sketched a two-box diagram on the whiteboard: browser, then a fast local cache, then the slower database behind it, and pointed at where the freshness delay would show up. For the finance manager, I connected the trade-off to their actual concern: fewer requests hitting the expensive database tier means lower infrastructure spend, which is why this was worth their budget attention. I checked understanding by asking each of them to describe, in their own words, what a customer might see if we set the freshness window too long; both correctly identified stale data as the risk, which told me the analogy had landed.

Result: they approved a staged rollout, and the finance manager specifically asked for the freshness window to start conservative and widen over time, which showed they'd internalized the actual trade-off rather than just agreeing. I learned to lead with the decision, not the mechanism, and that asking someone to apply the idea to a hypothetical is a much better comprehension check than asking if it makes sense.

Trade-offs and pitfalls

The pantry analogy is easy to over-extend; someone will eventually ask "what if two people put different snacks in at the same time," and a caching layer's real answer (a specific write and invalidation rule) doesn't have a clean pantry equivalent, so know where you'll stop extending it before someone finds the gap for you. The other common failure mode is treating a nod as confirmation, a stakeholder will often not admit they're lost mid-meeting, which is why an explicit restate-it-back check matters more than reading the room.

Direct answer

The second explanation almost never wins by being louder or more detailed than the first. It wins by changing the format, meaning I switch from telling to showing, and by rooting the explanation in a decision the person actually needs to make rather than in the mechanics of the tool itself. To avoid condescension, I treat the first miss as information about my explanation, not about their ability.

Structured elaboration

When a first explanation does not land, I go through a specific adjustment process rather than just repeating myself more slowly:

1. Diagnose what actually did not land, by asking a targeted question rather than re-explaining immediately. Usually the gap is one of three things: the vocabulary I used, the lack of a concrete example, or the fact that I explained the mechanism instead of the decision it enables.
2. Change the format, not just the pace. If the first pass was verbal, the second pass gets a visual or a live walkthrough. If the first pass was abstract, the second pass starts from a specific, real example the person already cares about.
3. Anchor the explanation in a decision they need to make, not in how the underlying system works. People retain "here is what you do when you see X" far better than "here is how X is calculated."
4. Check understanding by having them use it themselves, not by asking if it makes sense. Watching someone operate the thing and narrate their reasoning out loud surfaces exactly where the model in their head diverges from reality.

To avoid condescension, I frame the second attempt as "let me show you a different way to look at this" rather than "let me try explaining this more simply," and I never reference the fact that this is a repeat explanation in front of other people.

Worked example

I owned a dashboard that tracked monthly customer churn, acquisition channel, and cohort value for Product and Customer Success managers, most of whom were not technical. After my first walkthrough, several of them still could not use it to decide which customers to prioritize for retention outreach; they nodded along in the room but did not use it afterward.

For the second attempt, I changed three things. First, storytelling: instead of walking through the chart types, I opened with a real scenario, "we're seeing a spike in churn from one acquisition channel this quarter, here is what that costs us and how we'd catch it," and used the dashboard to answer that story as it unfolded. Second, guided filters: rather than describing the filters, I handed them the dashboard and had each person isolate a cohort and change the date range themselves while I coached, so the tool's behavior stopped being something I described and became something they had just done. Third, annotated visuals: I added in-dashboard annotations next to each chart naming the business question it answers, so the connection between a chart and a decision was visible without me being in the room. Afterward, I gave each person a short realistic scenario and had them talk through, using the dashboard, what they would do, which told me directly whether the explanation had landed rather than relying on their saying it made sense.

Trade-offs and pitfalls

• Switching format on the second attempt costs more preparation time than repeating yourself; it is worth it specifically because a second identical explanation rarely succeeds where the first one failed for the same underlying reason.
• Anchoring purely in decisions can under-explain the tool for a stakeholder who later needs to use it in a situation you did not walk through. If the audience needs durable independence, not just one correct decision, the mechanism has to come back in briefly, just after the decision framing rather than before it.
• The biggest condescension risk is not tone, it is implying the person should have understood the first time. Framing the second pass as offering a different angle, rather than a simpler one, avoids that without softening the actual content.
• Hands-on practice only works if you can tolerate the person making a visible mistake in front of you or others; rushing to correct every misstep undercuts the exact learning-by-doing effect you are relying on.

Direct answer

The number doesn't change across audiences, but what it's evidence for does: to a CEO it's a business outcome (conversion, retention, cost), to external developers it's a reliability guarantee they can build on, to internal engineering managers it's a load and capacity signal. Same 30% improvement, three different "so what," each with the one metric that audience should actually track next.

Structured elaboration

The technique is picking, per audience, which consequence of the number they actually own:

1. Translate the metric into the currency that audience is measured on before stating it. A CEO is measured on revenue and retention; an external developer is measured on their own app's reliability; an internal engineering manager is measured on system load and incident risk.
2. Give exactly one metric to track next, not a dashboard's worth. Too many numbers reads as "we're not sure which one matters"; one number reads as a clear owner and a clear signal.
3. State the baseline and direction explicitly, down from 500ms to 350ms, not just "faster," so nobody has to ask what the improvement actually was.
   This same three-move pattern is what you would reuse for a different metric to the same or different audiences: messaging a lazy-loading improvement to executives, sales, and developers, an API deprecation to engineering, customers, and executives, or a throughput doubling to a CTO, operations, and sales. The technique is constant; only which consequence you lead with changes per audience.

Worked example

p95 latency means the response time that 95% of requests are faster than, so it's a measure of how slow the worst-but-common cases are, not the average case.

To the CEO: "We cut the time it takes customers to sign in from half a second to a third of a second, 500ms to 350ms, a 30% improvement, on the slowest 5% of requests, the ones customers actually notice as lag. Faster sign-in means fewer people abandoning at login and less friction on every visit. Metric to track: conversion rate on the sign-up-to-first-action flow over the next two weeks, to see if that translates into fewer drop-offs."

To external developer customers: "Our authentication endpoint's p95 latency, the response time 95% of your calls beat, dropped from 500ms to 350ms. You should see fewer client-side timeouts and retries against this endpoint. Metric to track: your own timeout and retry rate against our auth endpoint, it should trend down."

To internal engineering managers: "We cut auth p95 from 500ms to 350ms through caching and query tuning, which lowers tail latency for every downstream service that calls auth before doing its own work. Metric to track: queue length and tail latency on the services immediately downstream of auth, to confirm the improvement is propagating rather than just moving the bottleneck."

Trade-offs and pitfalls

Reusing the same "30% faster" framing for every audience without a metric attached invites the follow-up "compared to what, and how would I know it's working," which is exactly what the per-audience metric answers in advance. It's also a mistake to promise a business outcome, like "this will increase conversion," as a fact rather than a hypothesis. Latency and conversion correlate but aren't guaranteed to move together for every product, so the honest version says "we would expect to see," not "this will." And if a later measurement shows a segment of customers saw no improvement, say a region or client version, that needs its own honest message rather than folding it quietly into the aggregate number.

Direct answer

The core move in an incident explanation to a non-technical audience is separating three layers up front: what happened (in plain terms, no root-cause mechanism), what it meant for them (impact, in terms they already track), and what's being done about it, then deliberately leaving out anything that doesn't serve one of those three. Below is an incident where I did that under time pressure, including delivering it live to a mixed engineering-and-business audience.

What to include, what to leave out, and how to decide

• Lead with impact, not sequence. Legal, sales, and executives care about what happened TO THEM first, which customers, how long, what's the exposure, the technical timeline is useful evidence, not the headline.
• Deliberately exclude logs, stack traces, and internal service names; they add authority for an engineering audience and add nothing but confusion for this one. A useful test: if a detail doesn't change what the listener should do next, leave it out.
• Give the cause in one plain sentence with no jargon, something like "a recent configuration change made one of our systems too slow to respond to a partner service in time," rather than either omitting cause entirely (which reads as evasive) or over-explaining the mechanism.
• When delivering this live rather than in a written report, whether it's a hallway update or presenting a postmortem verbally to a room that mixes engineers and business stakeholders, pause after the impact statement for questions before moving to cause. People worried about impact can't absorb a root-cause explanation until that worry is addressed first.

Worked example

Situation: during a high-traffic sales period, our payment service began intermittently failing checkout requests for roughly ninety minutes. Legal, sales leadership, and the executive team needed an explanation quickly.

Task: explain what happened clearly enough for them to act, communicate with affected customers, assess any obligations, decide on immediate next steps, without either alarming them with irrelevant detail or minimizing the impact.

Action: I opened with impact, in the terms they track: which customers were affected, for roughly how long, and that the issue was fully resolved and being watched closely. I gave the cause in one sentence: a recent configuration change made our payment service too slow to respond to our external payment gateway in time, causing some checkout attempts to fail. I described what we did in plain terms (reverted the change, increased how long we wait before giving up on a slow response, added an automatic circuit breaker so a slow dependency can't cascade into a wider outage) and what we were doing next (a deeper review, with a fuller technical writeup available to anyone who wanted it). I left out the specific error codes, service names, and configuration parameter, none of which changed what legal, sales, or the executives needed to do next. I paused for questions right after the impact statement, before moving on, and answered a legal question about customer notification obligations directly instead of routing it back to engineering jargon.

Result: legal and sales left with a clear, accurate picture of exposure and could communicate confidently with affected customers; the executive team approved the follow-up work (the circuit breaker and review) without needing to dig into implementation detail themselves, and a fuller technical postmortem was made available separately for the engineering team that wanted the mechanism-level explanation. I learned that pausing for questions right after the impact statement, before cause, kept people from tuning out a cause explanation they weren't ready to hear yet.

Trade-offs and pitfalls

Leaving out technical detail can read as evasive if you do it silently; I said "I'm not going to walk through the technical internals here, I'm glad to share those separately" so the omission was visible on purpose rather than hidden. The other pitfall is understating severity to keep the room calm, that erodes trust the moment the real scope becomes clear later. State the honest impact even when it's uncomfortable, and let the "what we're doing about it" section carry the reassurance instead of the impact statement itself.

Direct answer

The right analogy changes with the audience's actual decision, not just their technical fluency: an executive needs to know why a load balancer protects revenue and uptime, an operations teammate needs to know how it behaves under failure. Same object, two different "why this matters," and the analogy should carry that difference, not just simplify the vocabulary.

Structured elaboration

Building an analogy that survives a follow-up question, rather than one that just sounds nice, comes down to three moves:

1. Pick the analogy around the audience's actual worry. An executive worries about the business staying up; an operator worries about what breaks and how they'd know.
2. Decide up front what you are choosing to leave out, not just "simplify." For the executive, leave out routing algorithms and health checks entirely; for the operator, keep them, because that's what they will actually be paged about.
3. Know where each analogy breaks, and have the correction ready before someone pushes on it. A receptionist analogy breaks the moment someone asks what happens if the receptionist doesn't know a staff member just called in sick, which is exactly the health-check behavior deliberately left out of the executive version. Have a one-sentence bridge ready rather than getting caught flat-footed.

Worked example

To an executive: "Think of a load balancer as a receptionist for a busy office. Instead of every visitor walking straight to one overwhelmed staff member, the receptionist spreads people across whoever's free, so service stays fast and nobody gets stuck in line at one desk. If one staff member steps away, the receptionist notices and stops sending people there until they're back. That's what keeps the site up and responsive even when traffic spikes or one server has a problem."

To an operations teammate: "It's the traffic controller in front of your server pool. It health-checks each backend, pulls unhealthy ones out of rotation automatically, and spreads requests using a policy like round-robin (each server takes a turn in order) or least-connections (send the next request to whichever server currently has the fewest open requests). It's also usually where session stickiness and TLS termination (the encryption handshake behind HTTPS) live, so when a session drops or a certificate issue shows up, the load balancer is one of the first places to check."

Trade-offs and pitfalls

The most common wrong turn is stopping at "it splits traffic evenly," full stop, to either audience. That framing quietly drops health checks, which implies traffic keeps flowing to a dead server, the opposite of what a load balancer is for. It also drops session stickiness and TLS termination, which matters the moment someone asks why a login broke or where the certificate is managed. The fix isn't to cram all of that into the executive version, it's to keep the operator version complete and keep one bridging sentence ready for the executive version in case the conversation goes there.