I spent three years inside a university transformation programme watching a well-designed strategy struggle to become working software. The strategy was sound. The business case was approved. The roadmap was clear. And yet the distance between "what the steering committee wanted" and "what the development team built" grew wider with every sprint. Not because anyone was incompetent. Because the handoff between strategy and execution was never designed.
What You Need to Know
- The strategy-to-execution gap is the most common point of failure in enterprise programmes
- The gap isn't caused by bad strategy or bad execution. It's caused by a missing translation layer
- Bridging the gap requires people who can speak both languages: business intent and technical delivery
- The fix is structural: embed translators in the delivery team, not in a separate governance layer
Where the Gap Opens
Strategy documents speak in outcomes. "Reduce time-to-resolution by 40%." "Create a unified view of the customer." "Improve staff productivity." These are meaningful goals. They're also not buildable.
Development teams speak in features, tickets, and technical specifications. "Build an API endpoint that aggregates data from three systems." "Create a dashboard component with real-time refresh." These are buildable. But they've lost the connection to the business outcome they're supposed to serve.
The gap opens in between. Strategy says what. Development says how. Nobody owns the why behind each specific piece of work, and that why is what keeps execution aligned to intent.
67%
of well-formulated strategies fail due to poor execution
Source: Harvard Business Review, 2015
The Translation Problem
I've worked across law, government, education, insurance, and enterprise delivery. The translation problem looks the same everywhere.
Strategy produces a document. A 30-page business case, a roadmap deck, a transformation charter. This document goes to the delivery team. The delivery team reads it, interprets it through their technical lens, and starts building.
Three months later, steering reviews progress and says: "That's not what we meant." The delivery team is confused. They built exactly what they understood. The problem: they understood the words, not the intent.
This isn't a communication failure in the traditional sense. Nobody failed to communicate. The issue is that strategy and delivery think in fundamentally different frameworks. Strategy thinks in business outcomes, competitive positioning, and stakeholder value. Delivery thinks in systems, data flows, and user interactions. The translation between these frameworks is a skill, and most programmes don't have anyone whose explicit job it is to do it.
The Waterfall Trap
In waterfall delivery, the translation happens once at the start: a requirements document attempts to capture everything. The strategy team signs off. The delivery team builds to spec. Months later, what gets delivered matches the requirements but not the intent, because the requirements couldn't capture all the nuance, context, and judgement that informed the strategy.
The Agile Trap
Agile was supposed to fix this with continuous feedback. And it helps. But in enterprise contexts, the feedback loop often breaks. The product owner becomes a proxy for stakeholder intent, and over weeks of sprint refinement, the connection to the original strategy gets diluted. Individual stories make sense. The overall direction drifts.
Building the Bridge
The Translator Role
The most effective programmes I've been part of had someone, usually one person, whose job was to sit between strategy and delivery. Not a project manager tracking milestones. Not a business analyst writing requirements. Someone who understood both the business intent and the technical constraints well enough to make real-time translation decisions.
This person attends steering and sprint planning. They hear the strategy conversations and translate them into delivery priorities. They hear the technical constraints and translate them back into strategic tradeoffs. They catch misalignment before it becomes rework.
The best programmes I've run had one person who could sit in a board meeting in the morning and a sprint planning session in the afternoon and be equally useful in both. That person is the bridge.
Tim Hatherley-Greene
Chief Operating Officer
Outcome-Anchored Delivery
Instead of translating strategy into a feature list, translate it into outcomes per delivery cycle. "By the end of this quarter, users should be able to do X without manual intervention, measured by Y." This keeps every sprint connected to a business result, not just a backlog item.
The discipline: every two weeks, the team should be able to answer "what business outcome did this sprint contribute to?" If they can't, the gap is opening.
Shared Language
Strategy and delivery need enough shared vocabulary to spot misalignment. This doesn't mean executives need to understand APIs or developers need to read business cases. It means both sides need to agree on the key terms: what "real-time" means in this context, what "unified view" includes and excludes, what "productivity improvement" will be measured by.
Build a glossary early. Revisit it when new terms enter the conversation. It sounds simple. It prevents most of the "that's not what we meant" conversations.
The University of Canterbury Example
The Student First Programme was a three-year business transformation with agile teams of 35 people delivering monthly software releases for two and a half years. The scale meant the strategy-to-execution gap could have been catastrophic.
What worked: we embedded translators at every level. Each workstream had someone who could articulate the business intent behind their stream and make priority calls that reflected strategic goals. The programme board spoke in outcomes. The delivery teams spoke in features. The translators connected them.
What also worked: monthly releases meant monthly reality checks. If the delivery was drifting from intent, we found out in weeks, not months. The feedback loop was short enough that course corrections were affordable.
What didn't work: when translators rotated out and weren't replaced, their workstreams drifted. The correlation was clear and immediate. The role was load-bearing.
The gap between strategy and execution isn't a people problem. It's a structural problem. Strategies are designed in one language and executed in another, and most programmes don't invest in the translation layer that connects them. The fix isn't better strategies or better delivery. It's building the bridge between them and staffing it with people who can speak both languages.