Coachability, Feedback, and Humility Questions

Direct answer

I'd treat the public criticism as legitimate signal about business impact even if the underlying reliability decision was correct: acknowledge the impact first instead of defending the decision on principle, then re-examine the trade-off with real numbers. I'd look for a narrower design that protects reliability without simply overriding the business need, rather than treating it as a binary keep-or-remove choice.

Structured elaboration

Respond to the feedback. Leading with "the rate limit is necessary" dismisses their actual pain. Leading with acknowledging the customer-visible slowdown is real and worth solving buys the credibility to have the harder conversation next.

Manage the political fallout. Bring data, not defensiveness: quantify what the limit is protecting against and what it's currently costing in the feature's usability. Involve the affected teams in evaluating the trade-off rather than unilaterally deciding it was right.

Protect reliability without just blocking the business goal. Look for a fix narrower than "keep or remove the limit" entirely: scope it to the actual abusive traffic pattern rather than the whole feature, add a burst allowance for legitimate spikes, add caching or backpressure upstream (having the downstream system signal the upstream one to slow down instead of dropping requests) that reduces how often the limit is hit at all, or fast-track a capacity fix that makes the limit unnecessary at the current scale.

Worked example

I'd added a rate limit on an API endpoint after it caused a cascading outage during a traffic spike; the limit stopped the outage but also visibly slowed a client-facing dashboard feature during normal peak usage, and product and sales called it out publicly in a cross-team channel as making the product look broken to customers. I didn't open by explaining why the limit existed. I opened by saying the slowdown was real and asked for specific examples of where customers were hitting it, so I wasn't debugging a vague complaint.

Digging into the actual traffic, the limit was scoped too broadly: it applied uniformly to the endpoint instead of just the burst pattern that had caused the original outage. I re-scoped it to trigger only on the abnormal traffic shape, added a short burst allowance for normal peak load, and paired that with a caching layer upstream that cut baseline request volume enough that the endpoint was no longer close to the danger threshold under normal conditions. I reported back to the same channel with what changed and why, including the actual traffic numbers: at peak, only about 3% of requests were now hitting the limit, down from the 40%-plus spike that had caused the original outage, which mattered for not making it look like sales had simply won an argument.

Trade-offs and pitfalls

Capitulating and removing the limit to make the complaints stop re-opens the outage risk that motivated it in the first place. Digging in and defending the limit unchanged reads as prioritizing your own comfort over customer impact and burns trust with product and sales for the next disagreement. And treating this as purely a technical fix skips the part where you actually close the loop with the people who were publicly frustrated, so the reliability work stays invisible to them even after it's solved.

Direct answer

Treat mentorship on a specific skill as a short deliberate-practice loop (short, focused practice cycles aimed at one specific named weakness, with fast feedback after each attempt) rather than an open-ended relationship: name the exact skill gap, ask narrow questions tied to real work rather than abstract ones, request feedback on a fixed, fairly tight cadence while actively building the skill, and show the mentor concrete evidence of change rather than just asserting improvement.

Structured elaboration

• Name the skill area precisely. "I want to get better at estimating the risk in a technical proposal before committing to it" is something a mentor can actually coach. "I want to get better at my job" is not.
• Example questions, tied to real work. "In this proposal, where did I underestimate the risk, and what would you have looked for that I didn't?" "Looking at how I handled this ambiguous requirement, what's the pattern in what I'm missing?" Questions that reference a specific artifact get much more useful answers than questions about the skill in the abstract.
• Cadence. Tighter at the start, roughly weekly or every other week, while the skill is actively being built and mistakes are still common, so feedback catches the pattern before it's repeated many times. Stretch it out as independence grows, since a mentor's time is finite and the marginal value of very frequent feedback drops once the basic pattern has been corrected.
• Demonstrating progress over several weeks. Bring the same kind of artifact back at each checkpoint so the comparison is apples to apples, the third proposal reviewed against the first, and be explicit about what changed: "last time you flagged that I didn't account for the dependency on the other team, this time I called it out explicitly." This turns the mentor's role from repeatedly finding the same issue into actually watching it disappear, which is also what makes a mentor willing to keep investing time.

Worked example

A mid-level engineer wants to get better at scoping technical risk in proposals. Week one: brings a real proposal, asks "where did I underestimate risk here, and what signal did you use that I missed?" The mentor points out the estimate didn't account for a dependency on a team with a different release cadence. Week three: brings the next real proposal, having deliberately looked for cross-team dependencies this time, and asks the same style of question; the mentor confirms that risk is now covered, but flags a new pattern, underestimating the effort of migrating existing data. Week six: a third proposal shows the pattern from both earlier checkpoints being caught independently, and the check-in question shifts from "what did I miss" to "does my reasoning for this risk assessment hold up," a harder, more senior question that reflects the earlier patterns being internalized.

Trade-offs and pitfalls

Asking for feedback so frequently that it outpaces having anything new to show wastes the mentor's time and makes progress hard to see. Asking generic questions about the skill instead of anchoring each ask to a specific piece of real work produces generic answers back. Never showing the mentor evidence that earlier feedback was applied leaves them repeating the same correction indefinitely. And picking a skill area too broad to make visible progress on in a few weeks makes the whole loop feel directionless.

Direct answer

I treat a piece of feedback as a diagnostic signal, a possible symptom of something bigger, rather than a standalone complaint, by asking whether it could plausibly recur under a different name from a different person. When it does, I trace it back to the actual process, data, or definitional root rather than resolving the surface instance and moving on.

Structured elaboration

Reframing. Before responding to any one piece of feedback, ask: if this is really about some deeper issue, would I expect to see it show up somewhere else too? That turns an isolated complaint into a hypothesis worth testing, not just a one-time fix to apply.

Investigating. When the hypothesis holds, trace the feedback back through the actual process or pipeline that produced the confusing artifact, not just the surface symptom the person happened to notice. A definitional mismatch, a process gap, or a data-quality issue usually sits one or two layers behind the visible complaint.

Fixing the root cause. The fix is structural, redefining a term consistently, closing a process gap, correcting a data source, rather than a one-off clarification that leaves the underlying inconsistency in place for the next person to trip over.

Worked example

Two different stakeholders, in unrelated conversations a few weeks apart, told me the "engagement" numbers I'd shared didn't match what they were seeing on a separate team's dashboard, and each initially framed it as if the other team's number must be wrong. Instead of reassuring each of them individually that my number was correct, I noticed the pattern, two independent people hitting the same mismatch, and traced it back rather than re-explaining my calculation each time.

It turned out the two teams' dashboards used genuinely different definitions of "engagement": one counted any session, the other required a specific action within the session, and neither dashboard stated its definition anywhere visible. Both numbers were internally correct and had simply drifted apart in meaning without anyone deciding that on purpose. The fix wasn't reassuring the next person who noticed the gap; it was getting the two teams to agree on one shared definition, documenting it visibly next to both metrics, and adding a note explaining the one case where the numbers would still legitimately diverge. After that, the recurring "your numbers don't match" comment stopped, because the actual definitional root cause was gone, not just explained away each time it surfaced.

Trade-offs and pitfalls

Treating every single complaint as evidence of a deep systemic issue is its own failure mode; most feedback really is about the one artifact in front of you, and chasing a root cause that isn't there wastes time and can read as evasive. The harder skill is telling the two apart, which mostly comes down to whether the same underlying confusion shows up independently more than once. And fixing the visible symptom, re-explaining the number, without tracing it back means the same confusion, and the same erosion of trust in the metric, keeps recurring under a slightly different complaint each time.

Direct answer

Look for a case where a mentor didn't just critique the output of a workflow, but questioned the workflow itself, because that's the version of mentorship feedback that actually changes how you operate rather than just what you ship once. The strongest answer walks through the original approach, the specific feedback, the redesign, how you checked it actually helped rather than assuming it did, and how you got the people who depended on the old process on board with the change.

Structured elaboration

• Original approach. Describe concretely what the workflow was and why it existed in its current form, often because it grew organically, or was copied from somewhere else without being re-examined.
• The mentor's feedback. Name what the mentor actually said and, more importantly, why it landed, what assumption it challenged. The strongest version of this feedback usually isn't "this is slow," it's a reframe: "you're treating this manual step as necessary, but the reason it exists doesn't apply anymore," or "you're optimizing the wrong part of this process."
• The changes implemented. Be specific about what changed structurally: a manual step automated, a review gate moved earlier or removed, ownership of a handoff reassigned, a tool swapped. A vague "I streamlined the process" is weak; name the actual before and after.
• How you measured improvement. Pick something you can actually observe and describe it honestly, not a fabricated precision statistic. Structural counts (fewer manual steps, fewer handoffs, a recurring failure mode that stopped recurring) are credible and checkable; broad percentage claims without a real measurement behind them are not. Say plainly what you tracked and over what period, and be honest that some improvements are more "this stopped being a recurring problem" than a hard number.
• How you communicated the change to stakeholders. Name who depended on the old process and needed to be brought along, what you told them and when, before the change, not after, if it affected their work, and how you handled any resistance to the change.

Worked example

A mentor reviewing a recurring release process notices the candidate manually verifies five checklist items before every deploy, and points out that three of those checks duplicate what an automated test already covers, while the other two exist because of an incident from years earlier that no longer applies to the current architecture. The original approach: five manual pre-deploy checks, taking real time and occasionally skipped under time pressure, which had itself caused a near-miss once. The feedback reframes the problem: the candidate had been treating the checklist's existence as evidence it was still necessary, rather than re-deriving why each item was there. The change: the three duplicated checks are removed since the automated test already covers them, one of the two remaining checks is automated into the deploy pipeline itself, and the last one, the only one that genuinely still requires human judgment, stays manual but is documented with why it exists, so a future person doesn't have to guess. To check it actually helped, the candidate tracks whether the near-miss failure mode that originally justified the checklist recurs over the following release cycles (zero near-misses across the next six release cycles, versus one in the six months before the change), and whether deploys that used to occasionally skip the manual step under time pressure now consistently complete the much shorter remaining checklist. To bring stakeholders along, the candidate walks the team through the reasoning in a short written proposal before changing anything, naming the incident history behind each check so nobody feels like safety is being cut for speed, and gets sign-off from whoever owns incident response before removing anything.

Trade-offs and pitfalls

Making the change and only afterward telling the people who depended on the old process reads as unilateral, even when the change is objectively good. Describing the improvement in vague terms, "it's much better now," instead of naming something concrete that was actually tracked, weakens the story. Over-crediting yourself and under-crediting the mentor's reframe misses the point of the question, which is showing you could actually hear and act on someone else's insight. And removing a safety-motivated step without checking whether the original reason for it still applies repeats, in the other direction, exactly the mistake the mentor's feedback was pointing at in the first place.

Direct answer

Use a rough time-box and a cost check, rather than comfort level, to decide when to stop trying alone: if a bounded amount of time has passed without real progress, or if the cost of staying stuck starts to outweigh the usually smaller than imagined cost of interrupting someone, ask, and be honest when the real reason for the hesitation was ego or not wanting to look inexperienced rather than a good reason.

Structured elaboration

• Recognizing the hesitation for what it is. Name honestly what's actually driving the delay: is it genuinely productive persistence (still learning something by continuing to try), or something less useful, not wanting to look like you don't know something, or an assumption that a colleague is too busy that was never actually checked.
• Setting a decision rule instead of relying on feel in the moment. A rough time-box (if there's no meaningful progress after a set amount of effort, that's a signal) combined with a cost check: what does it cost the team if you stay stuck longer, versus what does it cost to interrupt someone for a few minutes. Most of the time the second cost is much smaller than it feels like while you're the one hesitating.
• Escalating well when the time comes. Come with what's already been tried, not just the problem, so the person being asked isn't starting from zero and can see the easy steps weren't skipped. This also makes it easier on the ego, since it demonstrates effort, not just an admission of being stuck.
• The result to describe. Name what actually happened once the ask was made, and if it turned out to be a smaller ask than it had been built up to be, say that honestly, since that's often the real lesson of these stories.

Worked example

Stuck on a configuration issue that's blocking progress, the hesitation to ask comes from not wanting to bother a senior engineer over something that might be "obvious." After roughly forty-five minutes of trying reasonable things with no real progress, and noticing the deadline is close enough that staying stuck another hour has real cost to the team, the message goes out: "I've tried X, Y, and Z, still stuck on this specific error, do you have five minutes?" The senior engineer recognizes the issue in under two minutes, a known gotcha they'd have mentioned earlier if asked. The result: the actual interruption cost almost nothing, far less than the imagined cost that had kept things stuck for forty-five minutes, and afterward there's more willingness to ask earlier next time rather than assuming it's a bother.

Trade-offs and pitfalls

Waiting so long that the eventual ask comes at the worst possible time, right before a deadline, turns a small interruption into a real emergency for the person being asked. Asking too quickly with no attempt of your own wastes the answer-giver's time on something findable alone, and doesn't build your own skill. Assuming a colleague is too busy without actually checking is often a story told to yourself rather than something they've said. And framing the ask apologetically or with excessive self-criticism makes the interaction more uncomfortable for both people than it needs to be.