How shared accountability helps teams own the product end to end

It started with a short support ticket.
Our most important customer reported that filtering in our application had slowed down, which was critical because it is one of the core functionalities.

Our development team started the investigation immediately.
They reviewed the code, optimized queries and caching, and tested everything in staging.
Everything looked fine.

So why was our biggest customer still experiencing poor performance?

We decided to try a different approach and investigate the issue together instead of passing it to another team.
Developers, DevOps and QAs joined the same call to review production metrics.

That was when we finally noticed the real problem.

Our ElastiCache cluster on AWS had been silently reaching its memory limit because no one was accountable for monitoring it.

Once we identified the issue, the fix was straightforward.
We increased the cache size and fine tuned its configuration.
Within minutes, performance returned to normal and response times were even better than before.

This was the moment when we realized that the problem was never the cache itself, but how accountability was distributed across the team.

The important part was not that we fixed it, but how we fixed it.

Accountability is a Team Sport

When DevOps Lives Inside the Team

In many organizations, including ones like ours, a problem like this would bounce between different competency teams. That makes complex issues harder to understand and even harder to solve.

DevOps handle infrastructure, developers focus on code and QA takes care of quality.

The problem is passed from one team to another, making the root cause harder to identify.

Before this incident, production was something most developers rarely looked at, but today production metrics are part of regular conversations. The difference is not tooling. It is accountability.

This approach made application development and maintenance, from code to infrastructure, everyone’s shared accountability.

When teams do not own the full lifecycle of their product, they lose both learning and accountability.

During this incident, nobody said “It is not my area”.
Instead everyone said: “Let’s find out”.

From Hidden Systems to Shared Understanding

That incident started something bigger.

Our developers became curious about what happens beyond local environments and wanted to understand infrastructure, monitoring and cloud architecture.

We decided to give them access.
They received dashboards, log insights and visibility in AWS.

Soon after, we organized internal sessions about caching, observability and cost optimization.
Some developers began AWS certification paths on their own.

Debugging stopped being the task of one team and became a shared effort.

If you hide production from developers, do not be surprised when they stop caring about it.

Giving access created engagement and energy.

The Real Lesson: You Build It, You Run It

You build it, you run it.

This is not about pushing accountability down.
It is about raising awareness.

The same team that builds the product should also run it, observe it and learn from it.
The entire team should be able to understand, diagnose and improve performance.

If your team cannot deploy, monitor, and troubleshoot its own product,
then it is not really your product.

This mindset changed how we think about software.
Every new feature now begins with a simple question:

How will we know it performs well in production?

This question shapes how we design, test and deliver value.

Accountability is a Team Sport

What Changed Long Term

Today, production is no longer something that lives in the background.
Production metrics are part of regular team discussions and planning.

New features are reviewed not only for correctness, but also for performance, observability and impact on the system.
Questions about monitoring, scaling and failure scenarios are asked early, not after incidents.

Accountability is no longer assigned during outages.
It is shared from the moment work begins.

As a result, teams respond faster, decisions are more balanced and trade offs between code, infrastructure and cost are made consciously.

Building Interdisciplinary Teams

We decided to make this approach part of our daily work. Each team now includes people with infrastructure, frontend, backend and QA expertise.

We think of organising “DevOps Fridays” where everyone can experiment with infrastructure as code, monitoring, or performance improvements.

We also invited developers to join postmortems and incident reviews.
Not to assign blame, but to understand how the system behaves under real traffic.
Questions became better and solutions became more thoughtful.

Over time, some engineers decided to go further.
They joined cloud and DevOps courses and started suggesting improvements that connected code, infrastructure, and cost.

Debugging stopped being reactive.
It became intentional.

Awareness led to confidence and confidence led to accountability.

By building knowledge and trust, real ownership is created.
That ownership translated into better performance and stronger collaboration.

Customers do not care if your architecture is elegant. They care if your app works fast on a Monday morning.

Now it does.

Photo by Arno Senoner on Unsplash
Photo by Arno Senoner on Unsplash

Growing Awareness Together

What helped us build accountability:

  • Access to production metrics and logs
  • Shared incident reviews without blame
  • Basic cloud education for developers
  • Clear ownership of systems, not tickets
Accountability is a Team Sport

Conclusions

Building great products was never about separating responsibilities into departments. It is about building teams that have all the skills needed to deliver value end to end.

When backend, frontend, devops and quality work together inside one team, the boundaries disappear. Problems are solved faster because the people who build the product also understand how it runs in production.

Accountability is not a mindset shift.
It is a structural decision.
It appears when teams are trusted to own the whole system.

Because at the end of the day:

You build it, you run it.