4 min read

You Cannot Outsource Accountability

In many organisations, teams describe dependencies in ways that shift responsibility elsewhere.
You Cannot Outsource Accountability

In many organisations, teams describe dependencies in ways that shift responsibility elsewhere:

  • "We are currently waiting for Platform to deliver this part."
  • "Progress is on hold until Infra completes their component."

This posture not only creates delivery risk. It often conveys a subtle form of disrespect. Few platform or SRE teams challenge the priorities or delivery structures of product or commercial areas, yet the reverse happens frequently. When a team publicly positions another as the blocker, without first offering solutions, they project blame rather than leadership. Over time, this erodes mutual trust, undermines healthy collaboration, and points to a deeper issue: a failure of leadership. Leaders who tolerate this pattern reinforce dependency culture rather than solve it.

The Simple Truth

You remain accountable for solving the dependency, even if you do not own the execution.

It again reflects poor leadership when this accountability is not exemplified. A modern platform ecosystem thrives on mutual contribution. Platform 2.0 is not a service, but a collaborative environment where products emerge from shared ownership. Platform teams work on outcomes like any other team. They bring order to complexity and build the enabling infrastructure that powers delivery. They do not mind where a prototype originates as long as it helps move the system forward.

All teams should act as agents of change, starting with product teams. The seeding prototype for any meaningful improvement can be initiated by any capable engineering team.

If documentation is missing, generate it. If self-service is lacking, suggest a pattern. Build a PoC. Reverse-engineer an OpenAPI contract with stubs. Show your platform partners how the problem might be addressed.

With AI tooling, reverse engineering documentation or bootstrapping interface proposals is easier than ever. These contributions are low-friction and high-trust.

Leadership does not begin with authority. It begins with action, initiative, and shared responsibility. Trust is not requested. It is demonstrated through contribution.

Extreme Ownership Begins with You

As a stakeholder, your responsibility does not end at flagging the issue.
It begins with proposing a solution, and doing so with empathy.

Platform teams also have strategic roadmaps. They, too, experience the pressure of aligning with company-wide priorities. Assuming they face the same struggle, and walking the extra mile to support them, builds trust where it matters most.

  • Can your team contribute directly?
  • Can you adapt the scope to unblock delivery?
  • Can you demonstrate the impact clearly enough to justify a shift in priorities?
  • Can you offer a working PoC or stub implementation to seed the discussion?
  • Can you build trust through clarity and initiative, rather than urgency and escalation?

Your first action should not be escalation. Your first contribution should be a collaborative proposal grounded in respect.

Accountability Differs from Execution

Execution may sit with another team.
Accountability for solving the dependency sits with the stakeholder.

True leadership does not mean multiplying alignment meetings. It means identifying who can help, unlocking capacity, unblocking the system. It means reducing friction by acting, not waiting.

Do not spend time blaming.

Build momentum. Create options. Move. Dare. Act.

Platform teams could just as easily ask what exactly you are contributing if your role is limited to commentary, pressure, and passive expectation. Pushing accountability downwards to those responsible for execution, without stepping up to own the dependency reveals a deeper leadership failure.

It means deflecting prioritisation responsibility, opting instead to participate in a blame game. This behaviour bloats platform teams, delays leverage delivery, and ultimately slows down the time to market that the organisation relies on. True accountability is not about demanding outcomes from others. It is about owning your share of the solution.

Platform Is Not a Service Desk

Platform teams are not ticket processors.
Treating them as such results in delay, misalignment, and disappointment.

Treat them instead as strategic partners.

Engage early. Share context. Clarify trade-offs. Align goals.


Co-own the problem.

The Mindset Shift

Shifting from passive to proactive starts with language, but it must translate into consistent behaviour.

🛑 Passive: "We are blocked."
📅 Active: "We face a dependency. Here is our current path to resolution. We are actively working with stakeholders to propose options and reduce latency."

🛑 Passive: "They own the delivery."
📅 Active: "We do not own the execution, but we are accountable for the outcome. We have provided context, offered support, and are tracking resolution alongside the platform team."

This mindset shift reinforces initiative, respects the constraints of others, and fosters shared ownership. It is not about perfection. It is about motion, clarity, and responsible engagement.

A Real-World Example

Consider a small but powerful case: a fiscalisation team wanted to experiment with an auto-rollback mechanism within the new CI/CD pipeline. Instead of requesting the feature or waiting for prioritisation, they built a PoC and shared it with the SRE team.

The result? SRE reviewed and validated the contribution, and the mechanism became a new mandatory module in the governed API deployment pipeline, now available to all teams.

This is what leadership through contribution looks like. It builds trust, accelerates capability, and shifts the dynamic from dependency to collaboration.

Final Thought

Dependencies are not blockers. They are catalysts for leadership.

In a collaborative engineering culture, the goal is not to avoid dependencies, but to navigate them with clarity, respect, and shared accountability.

Blame is easy. Motion is harder. But only motion builds momentum.

So next time a dependency surfaces, pause before assigning responsibility elsewhere.

Step in. Build options. Communicate clearly. Move first. Solve forward. Own the path.