If you have spent any time inside a large-scale enterprise rollout, you have heard some version of this exasperated question, usually delivered with a tight jaw during a weekly governance call.
The pattern is almost always the same.
A vusiness representative flags an operational gap. Perhaps a regional tax rule isn't handled properly, a warehouse handoff breaks down, or a reporting view is missing critical data. It goes onto the dashboard as a bright red flag.
Everyone agrees on the fix. The project team and developers put their heads down, build the functionality, and run a clean playback demo. On screen, it works.
Yet two weeks later, the steering committee opens the deck, and that exact same red flag is still glowing.
From the project team’s perspective, this feels baffling, even ungrateful. They did their job. They delivered the solution. Why is the local team refusing to turn the light green?
Over the years, I have watched this standoff erode trust between central build teams and local business units. When you look beneath the surface, it rarely comes down to stubbornness or poor communication. It is usually a collision between two completely different realities. In an IT or project delivery mindset, a requirement is resolved the moment the code is configured and survives a clean demonstration. For a local business lead who has to answer for it if trucks stop moving or customer orders stall on Monday morning, a scripted demo proves very little. Until their own people have pushed real, messy operational scenarios through that workflow, the risk is still very much alive.
Often, the red flag isn't lingering because the business doubts the software. It is lingering because the exact key users needed to test it are drowning in their regular day jobs. When leadership demands business ownership without funding operational backfill, user acceptance testing gets shoved to Friday afternoon, week after week. The red flag stays up simply because nobody has had three uninterrupted hours to verify the fix.
Sometimes a feature looks fine during a fast-paced screen share, yet local practitioners quietly sense a subtle flaw in how it connects to their downstream process. Rather than arguing with developers in a crowded call, teams sometimes stall on testing, leaving the red flag on the report as an unspoken shield until someone sits down to look closer.
So how do you break the stalemate without turning governance calls into a defensive scoreboard? In practice, I see programs contemplate several different ways out.
Instead of treating status reporting as a binary choice between Red (crisis) and Green (completely done), some programs explicitly align both sides on a shared vocabulary. Red means there is an unattended risk. Amber means the risk has been addressed (e.g. the solution is built), but the business is still verifying operational safety. That single shift lowers the temperature in the room. The build team gets visible credit for delivering, while the business keeps its safety net without being pressured into a dishonest green light. The catch? You have to watch out for two subtle traps. If Amber is tied purely to an emotional sense of feeling “comfortable,” cautious teams can park items in Amber indefinitely as a political shield. At the same time, executive steering committees often treat Amber as “basically fine” and stop paying attention, only to be blindsided two weeks before cutover when twenty untested Amber items suddenly turn back into Red blockers.
Other programs stop using a single status indicator that mixes technical delivery with business sign-off. Instead, they track Solution Built and Business Verified as two separate gates. Developers get clean credit for hitting their milestones, and testing bottlenecks become impossible to hide. The trade-off? People often dislike split dashboards because they create an uncomfortable sea of half-green, half-red rows that are harder to summarize and analyse.
Another approach is to keep the escalation visible, but change its label. If a built feature sits untested for more than ten days, it stops being reported as a functional gap and becomes a capacity escalation aimed squarely at local management. This forces leadership to confront the reality of un-backfilled Key Users. On the flip side, it can quickly turn operational status meetings into political battles over departmental budgets and priorities.
Rather than waiting for overwhelmed business users to find quiet time at their desks to run test scripts, some teams pull the developer, the local TMT lead, and two experts into a 90-minute session to test the feature together using real business cases. It compresses weeks of stalled back-and-forth into a single afternoon and builds genuine shared ownership. The downside is that it is heavy to coordinate across time zones and difficult to scale if dozens of local items are piling up at once.
Every rollout carries its own balance between delivery speed and operational safety, and what works in a centralized commercial team can fall apart in a complex manufacturing environment.
I am curious how other project directors, TMT leads, and change practitioners navigate this standoff.
When a technical fix is built and demoed, yet local business testing stalls, how do you calibrate your reporting, and how do you get both sides moving again?