Influence and Persuasion Questions

Situation: I led a launch that needed Product, Engineering, and Support to deliver the same outcome, which was reducing customer setup time.

Task: Each team had different priorities, so I needed one shared goal and a way to surface trade-offs early.

Action: I started with a single business metric, then broke it into team-level commitments. Product owned the user flow, Engineering owned reliability, and Support owned readiness. I held a weekly cross-functional checkpoint where each team shared risks, not just status. When conflicts came up, I made the trade-off explicit. For example, we chose to delay one nonessential feature so we could simplify onboarding and reduce support tickets.

Result: The teams stayed aligned, the launch shipped with fewer surprises, and the process made future collaboration easier because everyone knew how decisions would be made.

The key lesson was that shared outcomes work best when the goal is visible, disagreements are discussed early, and trade-offs are decided openly instead of being left to drift.

Direct answer

Convincing a skeptical engineering team works the same way convincing any technical peer does: a working prototype and real measurements under realistic conditions, framed around the team's own operational incentives (on-call burden, SLA risk, meaning the risk of missing the SLA, short for service-level agreement, a committed target for uptime or response time that the team is held to, and cost they're accountable for), and a rollout plan that limits their exposure if the bet turns out wrong.

Structured elaboration

Framework:

1. Find the team's actual objection. It's usually operational risk or migration cost, not disagreement with the idea itself.
2. Build the smallest prototype that produces real evidence under realistic traffic, not a synthetic benchmark.
3. Translate the result into the team's own incentives: fewer pages, lower SLA risk, cost they own, not just "it's faster."
4. Propose a reversible rollout: a feature flag, a canary (a canary release: rolling the change out to a small slice of real traffic first, so any problems show up on a limited group before the change reaches everyone), a defined rollback trigger, so agreeing doesn't feel like a one-way door.

Worked example

Situation. At a company serving a vision model through CPU-based microservices, the on-call rotation was regularly paged during traffic peaks. The infra team was skeptical of a GPU-backed migration, worried about operational complexity and vendor lock-in, having been burned before by a migration that added more toil than it removed.

Stakes. Staying on CPU meant recurring SLA breaches and on-call fatigue, but the infra team's skepticism, left unaddressed, meant the migration simply wouldn't happen regardless of the theoretical performance case.

The influence moves.

• Talked to the on-call engineers directly, not just their manager, and learned the real objection wasn't the GPU idea itself but the memory of a prior migration that shipped without runbooks (a runbook is a written, step-by-step guide for operating or recovering a system, so whoever is on call at 2am has an actual procedure to follow instead of improvising) or a rollback path.
• Built a small prototype on a single GPU node and ran it against a slice of real production traffic over a short pilot window, rather than a synthetic load test, so the team could see behavior under conditions they recognized.
• Framed the result in terms the team owned: fewer pages during peak traffic and a lower likelihood of breaching the SLA they were accountable for, not just raw speed.
• Addressed the vendor lock-in and complexity objection directly: proposed a portable, standard runtime rather than a vendor-specific one, and delivered a runbook and autoscaling policy alongside the code, treating operational readiness as part of the deliverable.
• Proposed a gradual, flagged rollout with a defined rollback trigger tied to error-rate and latency regressions (an automatic rule that watches two production health signals, the percentage of requests failing and how slow responses get, and rolls the change back on its own if either one crosses a set threshold), so the team wasn't betting the whole service on day one.

Resolution. The infra team co-owned the rollout plan and adopted the runbook as their own; the prior migration's bad memory stopped being the default reason to say no.

What a senior candidate does differently. Doesn't lead with performance numbers; leads with the team's actual objection (the operational scar tissue from before), and treats the runbook and rollback plan as part of the pitch itself, not paperwork produced after the team says yes.

Trade-offs and pitfalls

• A synthetic benchmark convinces almost nobody who owns the pager. Realistic, even narrow, production traffic carries far more weight than a bigger but synthetic number.
• Skipping operational-readiness work to "prove the architecture works first" is a common mistake; for the team that has to operate it, the runbook and rollback plan are the pitch.
• A migration that can't be rolled back cheaply reads as a one-way door regardless of technical merit, and skeptical teams correctly resist one-way doors more than they resist new technology.

In the first week, I would focus on protecting the launch while testing whether the plan is still realistic.

Day 1 and 2: I would get the facts. What is late, what is truly on the critical path, and which milestones depend on the partner. I would also ask for a written status update so there is one shared view of the problem.

Day 3 and 4: I would reset alignment with the partner and internal leaders. I would make the risk visible, propose a recovery plan, and define what needs to happen by when. If needed, I would narrow scope, add internal backup work, or create a phased launch so the entire roadmap is not blocked by one dependency.

Day 5: I would decide whether the original date is still credible. If the partner has recovered, I keep the plan. If not, I recommend a revised timeline with clear trade-offs, rather than hoping the delay disappears.

The key is to avoid passive waiting. Even without direct authority, I can protect the launch by clarifying ownership, escalating early with options, and keeping leadership informed with facts instead of optimism.

For example, in a case like this, the launch depended on a third-party payments provider delivering a new API endpoint that a checkout redesign needed to go live. On Day 1, the written status update from the vendor's account manager revealed the endpoint was not late by a day or two, it was still in the vendor's own internal QA with no committed date, three weeks past their original commitment. By Day 3, resetting alignment meant a joint call with the vendor and internal engineering leadership where the risk was made explicit: without the endpoint, the full checkout redesign could not ship on the original date. The recovery plan split the work: internal engineering built a fallback that used the vendor's existing, older endpoint for most transaction volume, while the new endpoint's remaining edge cases, a smaller set of international payment methods, were scoped out of the initial launch and phased in once the vendor delivered. On Day 5, the vendor still had no firm delivery date for the new endpoint, so the recommendation was to launch on the original date with the phased fallback rather than slip the whole roadmap, with a follow-up launch for the remaining payment methods once the vendor's endpoint actually shipped.

Direct answer

When the blocker is skepticism, not a lack of information, the fastest way through it is to give people something to react to instead of something to be convinced of: a working prototype, a runnable demo, or a scoped pilot that lets them see the outcome rather than take your word for it. The artifact does the arguing; you just have to build the right one for the specific doubt in the room.

Structured elaboration

Step 1: diagnose the shape of the skepticism before picking an artifact. "I don't believe it" comes in different flavors, and the wrong artifact wastes the build effort:

Step 2: design the artifact around the objection, not around what's easiest to build. Scope it to the smallest thing that resolves the specific doubt, timebox it, and agree on pass/fail criteria before you start building, ideally with the skeptic's input, so the result isn't yours to spin.

Step 3: know where this can backfire. A demo built to impress rather than to test invites the objection "that's not how it'll behave in production." A notebook you hand over to build trust can just as easily hand ammunition to an opponent if it surfaces an edge case you hadn't accounted for. A pilot with too small a sample or a novelty effect can look causal and not be. Build the artifact to survive scrutiny, not just to look good once.

Worked example

Situation: a data science team built a new lead-scoring model intended to replace the manual process Sales used to decide which inbound leads to call first. Product also had to sign off, since routing the score into the CRM meant committing engineering time away from the roadmap. Neither audience would take "the model scores well offline" as sufficient: Sales trusted their own read on which leads convert, and Product didn't want to fund an integration for a metric that might not move revenue.

The pilot: rather than opening with the model's offline accuracy numbers, the team proposed a one-month randomized pilot. Every new inbound lead was randomly assigned, evenly, to one of two queues: the existing manual triage order (control) or the model-ranked order (treatment). Reps worked whichever queue they were assigned and were not told which queue was which. This is the deliberate causal design piece: random assignment is what lets a difference in outcomes be attributed to the model rather than to which reps happened to get the stronger leads that month.

Pinned inputs: 800 leads entered the pilot, split 400 to each queue by the randomization. The control queue converted 52 leads to a qualified opportunity. The treatment queue converted 71.

$$\text{Control conversion rate} = 52 / 400 = 13.0\%$$ $$\text{Treatment conversion rate} = 71 / 400 = 17.75\%$$ $$\text{Relative lift} = \frac{17.75 - 13.0}{13.0} \approx 36.5\%$$

Presenting to Product and Sales required two different framings of the same result. For Sales, the pitch led with what a rep actually cares about: working the model-ranked queue closed proportionally more leads for the same headcount and the same hours worked that month, which answers "will this replace my judgment with something worse" with results instead of an abstract accuracy score. For Product, the pitch led with the causal design itself: because assignment was random, the lift could be attributed to the model and not to seasonality, a strong sales month, or which reps happened to be on which queue, which is what justified spending engineering time on the full CRM integration rather than commissioning another manual audit of the leads process.

What a senior person does differently: they design the pilot's comparison before building anything (a held-out or randomly assigned control group, not a before/after on the same population), they pick pinned inputs and show the arithmetic rather than asserting a final lift number, and they prepare two distinct framings of the identical result for Product and Sales rather than one deck that tries to land with both.

Resolution: Sales agreed to route new leads through the model by default going forward, and Product approved the CRM integration in the next sprint. The causal design was what made the result durable: had the comparison been a simple before/after on the same population instead of a randomized control, either team could have credibly attributed the lift to a stronger sales month rather than to the model.

Trade-offs & pitfalls

• Building a good artifact costs real time; it only pays off when the resistance is genuinely about evidence, not about competing priorities or politics. A prototype won't fix a stakeholder who has a different agenda.
• A rehearsed demo and a reproducible artifact earn different kinds of trust: a scripted demo is faster to build but easier to distrust; a notebook or environment the audience can rerun themselves is slower to prepare but harder to dismiss.
• An artifact-driven win still needs a path to the actual ask. A convincing demo that nobody follows up on just becomes "a nice thing we built once."
• Watch for optimizing the artifact for the happy path. If the skeptics' real objection is an edge case, a demo that avoids it doesn't persuade, it confirms the suspicion that you're not taking the concern seriously.

I would diagnose this in four layers: alignment, execution, incentives, and measurement.

First, alignment. I would check whether everyone still agrees on the problem statement and the target outcome. If different leaders define success differently, teams can stay busy without moving the business.

Second, execution. I would review what actually shipped, what was adopted, and where the process slowed down. Busy meetings and shipped deliverables do not prove value if the critical users never changed behavior.

Third, incentives. I would ask whether teams are rewarded for the new outcome or for protecting their own function. If a team is measured on local throughput, it may resist work that helps the overall initiative.

Fourth, measurement. I would compare leading indicators and lagging indicators. For example, if a support automation project shipped six features but ticket volume did not drop, I would look at adoption, usage, and customer behavior before calling it a success.

I would bring leadership a simple readout: what was intended, what changed, where the bottleneck is, and what evidence supports that conclusion. That gives leaders a choice between fixing alignment, adjusting incentives, or changing the plan.

For example, on a two-quarter initiative to reduce customer support ticket volume through a new self-service help center, the four-layer check found: alignment was actually fine, everyone agreed the goal was fewer repeat tickets, not just more help-center pageviews. Execution had shipped six planned articles and a new search widget on time. Incentives were fine too, the support team was measured on ticket deflection and had every reason to want the initiative to work. The real problem was measurement: the team had been reporting help-center pageviews as the success metric, which had gone up 3x, but nobody had checked whether the same customers who viewed an article still opened a ticket afterward. Pulling that number showed 71% of pageviews were followed by a ticket within 24 hours anyway, meaning the articles were being read but weren't actually answering the question. The recommendation to leadership was not to kill the initiative or blame the team, but to replace the pageview metric with a deflection rate (viewed an article and did not open a ticket) and to revise the two articles with the worst deflection rate. Leadership approved continuing the initiative under the corrected metric rather than shutting it down, and deflection rate became the standing measure for the next quarter.