The red light dilemma: How to prevent workflow failures

Let´s talk about workflow failures.

There’s an old dilemma in system engineering that poses a deceptively simple question:

If a system has a red light that signals when something goes wrong, what happens when the red light itself fails?

The obvious answer would be to add another red light to monitor the first one. But what if that second light also fails? Do we keep adding more lights? At what point does the monitoring system become an endless loop, where managing the alerts becomes more complicated than solving the actual problem?

What’s fascinating about this dilemma is that it doesn’t just apply to engineering. It happens all the time in business management, team leadership, and workflow optimization.

The red light in team management that avoids workflow failures

Companies love adding layers of control and supervision to prevent failure. But there’s a breaking point. When a workflow or a team depends on too many monitoring layers, management itself becomes the problem, not the solution.

A few examples:

• A workflow automation system detects process errors. But if the automation fails, who catches that?
• A team has a manager to oversee performance. But if the manager isn’t doing their job, who supervises them?
• A reporting system tracks key metrics. But if no one actually reviews the reports, are they really doing anything?

The standard corporate response is to add more controls—more supervisors, more reports, more dashboards. But this doesn’t fix the root issue. It just creates more bureaucracy, slowing down decision-making and turning what should be simple processes into an administrative nightmare.

What starts as an effort to prevent failure ends up creating rigid structures, delays, and frustrated employees trapped in never-ending approval loops.

So, what’s the real solution?

The issue isn’t the lack of control—it’s the lack of self-regulation. Instead of flooding a company with alarms, supervisors, and unnecessary reports, it’s far more effective to design systems and teams that can identify and fix problems on their own.

1. Smart redundancy

More managers and more reports aren’t the answer. The key is a smart distribution of responsibility:

• Build self-sufficient teams that can troubleshoot and solve problems without excessive oversight.
• Integrate self-check mechanisms into workflows instead of relying on endless alert systems.
• Create structures where employees can report issues naturally, without unnecessary layers of approval.

Example: Instead of requiring five different levels of approval for a project, define what decisions can be made at the team level without waiting for managerial approval.

2. A culture of self-diagnosis and accountability

The best control mechanism is the one that teams apply to themselves. When employees are empowered to assess their own performance, problems get solved before they escalate.

• Encourage continuous feedback loops instead of waiting for formal performance reviews.
• Train employees to spot and address issues within their scope of work.
• Avoid micromanagement. Most people know what they need to do—they just need trust, not constant supervision.

Example: Instead of relying on quarterly performance reviews, implement weekly check-ins where teams reflect on their progress and make real-time adjustments.

3. Less reporting, more useful insights to avoid workflow failures

Reports are only valuable if they provide clear, actionable information. But in many organizations, dashboards and performance reports turn into white noise—filled with irrelevant metrics no one actually reads.

• Eliminate unnecessary reports.
• Focus only on key indicators that directly impact business outcomes.
• Make reports simple and digestible, so teams spend less time analyzing and more time acting.

Example: A sales team that spends hours reviewing minor metrics is inefficient. A smarter approach would prioritize just the top 3 KPIs that actually influence revenue and alert the team only when action is required.

4. Build workflows with cross-validation

A strong workflow doesn’t need constant supervision. Instead, it should be designed to self-validate.

• Incorporate automated checks so processes flag their own failures.
• Use monitoring tools that escalate only critical alerts, avoiding information overload.
• Create backup mechanisms that ensure processes keep running even when failures occur.

Example: An online payment system that automatically detects failed transactions and notifies users—without requiring a finance team to manually review every case.

5. Encourage direct communication, not excessive hierarchy

When communication flows naturally, there’s less need for heavy oversight. The most efficient companies don’t rely on employees waiting for instructions—they trust teams to communicate, collaborate, and act.

• Enable direct team-to-team communication without unnecessary intermediaries.
• Use internal communication tools that simplify problem-solving.
• Prioritize clarity over excessive information flow.

Example: Instead of waiting for an official report, allow teams to escalate and solve issues informally through a dedicated Slack channel or quick check-ins.

In some cases, workflow failures aren’t caused by poor execution—but by outdated systems that no one has fully assessed. That’s where structured evaluation becomes essential. Instead of piling on controls, companies should step back and audit how their operations really function. A well-executed operational audit helps identify the root causes of workflow breakdowns, guiding meaningful improvements without adding unnecessary complexity.

Conclusion: To avoid workflow failures don’t add more red lights—build resilient systems

Regarding workflow failures, the red light dilemma teaches us that more control doesn’t always mean better control. Instead of adding more oversight, businesses should focus on:

• Distributing responsibility intelligently.
• Encouraging self-regulation in teams.
• Optimizing workflows to reduce unnecessary bureaucracy.
• Using reports and data strategically, not excessively.
• Creating communication systems that allow fast, effective problem-solving.

If employees are spending more time reporting problems than solving them, your system isn’t efficient—it’s broken.

And remember: when you detect workflow failures, the solution isn’t adding another red light. It’s designing a system that doesn’t rely on red lights in the first place.