Showing posts with label engineering leadership. Show all posts
Showing posts with label engineering leadership. Show all posts

Saturday, November 29, 2025

Perverse Incentives, Predictable Results: When Your System Sabotages Your Teams

It's a strange paradox. It took the manufacturing industry 50 years to move past the ideas of Frederick Winslow Taylor, known as Taylorism or Scientific Management. Yet in software development, a creative, knowledge-based discipline where these ideas are least effective, we continue to apply them universally.

Taylorism in a software context is the practice of maximizing the local utilization of each individual. We treat people like resources in a factory, keeping them 100% busy with their specialized tasks. This creates a cascade of perverse incentives that actively undermine collaboration, destroy flow, and cripple the efficiency of the entire system.

This article explores the three most common traps this thinking creates and offers a practical, systemic path toward improvement.

1. The Trap of Resource Efficiency

The Core Fallacy

Most organizations are obsessed with individual performance and 100% resource utilization. The goal is to keep every person busy all the time, believing this equates to maximum productivity. However, basic queueing theory teaches us that running any system at full capacity only generates blockages, chronic bottlenecks, and massive wait times. As a wise colleague once said, "If we optimize locally, in most cases we make everything worse."

The Connection to Taylorism

This is a direct application of Taylorism: maximizing the utilization of each "human resource" locally. We decompose work, assign it to specialists, and measure them on their individual output, ignoring the devastating impact on the system as a whole.


The Consequences

When you incentivize local optimization, the negative results are entirely predictable.

  • Perverse local incentives: We reward metrics that are easy to measure but destructive to the whole. This includes rewarding a high number of commits, celebrating people for "being 100% busy," or lionizing "heroes" who constantly put out fires.
  • Predictable negative results: These incentives inevitably lead to chronic bottlenecks, constant rework (also known as "failure demand" because you're fixing things that failed the first time), and a toxic hero culture where knowledge is hoarded and collaboration is discouraged.

The Alternative: Flow Efficiency

The antidote to this trap is shifting our focus from resource efficiency to flow efficiency. The book This is Lean explains the difference well.

  • Resource Efficiency: This is a process where work is handed off between specialists in silos. To keep each specialist busy, a queue of work forms before each handoff. From the customer's perspective, this is incredibly inefficient, as their request spends most of its time waiting in a queue.
  • Flow Efficiency: This is a team-based approach where everyone collaborates to finish a single piece of work. There are no "my parts." The team owns the work from start to finish. This delivers value to the customer much faster and eliminates the immense waste and rework inherent in siloed handoffs.

2. The Trap of Disconnecting from "Why"

The "Feature Factory" Anti-Pattern

A common anti-pattern is the "feature factory," where teams operate like an assembly line. Someone defines requirements, others implement them, and no one on the team connects with the customer or the actual impact of the work. Success is measured by output, not outcome.

The Connection to Taylorism

This is another core tenet of Taylorism: the rigid separation of "thinkers" from "doers." It promotes the unquestioning execution of specifications, regardless of whether those specifications actually solve a real customer problem.

The Predictable Results

Building without a clear purpose has disastrous and wasteful consequences.

  • Irrelevant products: Features are built that nobody uses.
  • Wasted talent: People work hard on things that simply don't matter.
  • Unnecessary complexity: Technology is over-engineered without a connection to a real-world need, creating a massive maintenance burden.

Advocate for Empowered Teams

The alternative is an empowered product team that deeply understands the purpose of its work: what problem they are solving, for whom, and why. These teams don't just blindly follow specs; they adapt solutions to meet real user needs, achieving far greater impact and velocity with less effort.

The Evolution to a Product Team

The journey from a siloed, handoff-driven process to a true product team is an evolution. An effective model shows the team's boundary of collaboration expanding across the entire value stream. In a traditional Waterfall model, each step (Opportunity Selection, Design, Build, Test, Release, Run) is a separate silo. In an ideal Product Team, the entire team collaborates across the whole process, from identifying the opportunity to operating the solution and learning from its impact.

3. The Trap of Deferred Quality

The Core Myth

There's a false dilemma that pits quality against velocity. We're taught to believe there's a tradeoff: you can be "fast without quality" or "slow with quality." This is a foundational myth in our industry.

The Truth

The data is clear. As shown in years of research from the Accelerate/DORA reports, the highest-performing teams have both high quality and high speed. The truth is: Quality does not compete with velocity; it enables it. Of course, context matters. A one-shot script, an MVP, or a proof of concept have different quality constraints than a core product. But for any sustainable product development, building quality in from the start through practices like testing and fast feedback is the only path to sustainable speed. A low-quality approach leads to a progressive slowdown as technical debt and failures accumulate.

The Connection to Taylorism

This myth is a direct descendant of a Taylorist mindset. It treats productivity as a measure of immediate outputs, ignoring sustainability. Quality is seen as a separate, final inspection phase, rather than something built into the process from the beginning.

The Negative Cycle

This mindset creates a system that actively discourages quality.

  • Perverse Incentives: The system rewards behaviors that produce low quality. We celebrate heroes who fix crises (often of their own making), equate long hours on weekends with commitment, and reward improvised hacks that create future problems.
  • Predictable Results: The consequences are severe and unavoidable. Teams are trapped in a cycle of chronic firefighting. Technical debt grows relentlessly, and the organization suffers from a high rate of talent drain as good people flee the constant chaos.

4. The Path Forward: Systemic Improvement

As W. Edwards Deming taught, over 90% of an organization's performance is a result of the system, not the individuals within it. The responsibility of management is not to blame people but to change the system so that work can flow and people can grow.


Here are actionable strategies to start changing your system.

Lead by Example

As a manager, you must model the behaviors you want to see. If you want teams to write tests, you should write tests. If you want them to refactor, you refactor. Make the desired behaviors visible and celebrate them publicly. Your job is to improve the system, not to find culprits.

Embrace Blameless Postmortems

Analyze incidents and errors transparently with the sole purpose of finding and fixing systemic weaknesses. The goal is to learn and improve, not to assign blame. When the system allows a mistake to happen, the focus must be on strengthening the system.

Show Vulnerability to Build Safety

To create an environment of psychological safety where people feel comfortable highlighting problems, leaders must be the first to show vulnerability. I often share my own past mistakes like the time I took down the phone system for an entire town or made a critical DNS error. Sharing these stories openly shows that errors are a part of work and that the important thing is what we learn from them.

Hack Your Performance Reviews

Traditional performance reviews are often toxic, reinforcing the individualistic, Taylorist mindset. If you are required to use them, hack them. Sometimes you must reinterpret corporate-level mandates to create the right local incentives. Subordinate individual accomplishments to the person's contribution to the team's overall impact. Focus on how they helped the team succeed, not just what they did on their own.

Build End-to-End Ownership

Create cross-functional teams that own a problem from end to end. This often means fighting against the silo mentality. A strategy I've used is to have my team actively take on more work (like operations or QA tasks) to eliminate external dependencies. This gives the team full control, deepens their knowledge, and allows them to optimize for the entire value stream.

Redefine 'Done'

A task is not "done" when the code is committed. It's not "done" when it's deployed. Work is only truly "done" when its impact on the customer has been validated with real feedback. This reinforces a product mindset and focuses the team on outcomes, not just output.

Hire for Mindset

Prioritize mindset and attitude over a checklist of specific technical skills. You can teach someone a new programming language; it's much harder to teach them that quality is their responsibility.

  • Product Thinking: Ask product management questions in interviews, like "What products do you admire and why?" or "How would you measure the impact of this feature?" Invite product managers into engineering interviews to help assess this.
  • Collaboration: Assess real collaboration, not just talk. When possible, have candidates work with the team for a day (in a paid, respectful way) on a real problem.
  • Flexibility: Your career path must reward generalists who provide flexibility, not just specialists.

Master Your Workflow with Kanban

Many teams use Kanban boards, but few use them correctly as a pull system. The three most important rules are:

  1. Use WIP (Work In Progress) limits. This is the simplest and most powerful way to optimize flow.
  2. Read the board from right to left. During stand-ups, review the work, not the people. Start with what's closest to being "done" (validated impact) and work backward. The focus must always be on finishing work, not starting new work.
  3. Use slack to unblock. When WIP limits leave someone without an immediate task, they should not pull new work. Their job is to help colleagues with open tasks, unblocking work further down the chain.

Reducing Resistance by Turning Change Into Experiments

The status quo naturally resists change. To move forward, we need to build the capability to generate change continuously, not just through occasional big initiatives. Approaches inspired by Lean Change Management can help: make small, frequent adjustments, learn quickly, and evolve based on evidence rather than assumptions.

One powerful tactic is to present changes as experiments. Framing them this way reduces resistance, creates psychological safety, and encourages people to engage with curiosity rather than fear. Even when the goal is meaningful transformation, breaking it into small, testable steps makes progress far more sustainable.

Define clear success criteria and a limited timeframe. This lowers resistance and allows you to validate ideas with data. As Grace Hopper famously said, “It’s easier to ask for forgiveness than it is to get permission.”

Conclusion: A Better Way to Work

A bad system will always defeat a good person. The Taylorist principles so common in our industry create systems that are destined to fail, leading to wasted effort, frustrated teams, and mediocre results.

We are discovering better ways to work. Through this experience, we have learned to value:

  • Collaboration and shared responsibility over heroes and a culture of blame.
  • Global optimization over local efficiency and specialized silos.
  • Significant impact and results over occupation and "being busy."
  • Autonomy with purpose over rigid control and supervision.
  • Continuous learning and adaptation over predefined and static processes.

By focusing on changing the system instead of blaming the people, we can create environments where teams can truly thrive and deliver exceptional value.

Management frameworks and their impact on software development.

Further Reading and Resources


Monday, September 01, 2025

My premises about engineering leadership and people management

As with software development, I find it useful to write down the principles that guide how I think about leadership and people management. These are not universal truths, but they are the foundations I rely on when building and leading engineering teams. By making them explicit, I aim to create clarity, alignment, and a shared understanding of how I see leadership, collaboration, and growth.

  1. People are not resources I don't believe in treating people as interchangeable units or "resources." People are creative, motivated, and responsible when given the right environment. My default stance is trust, not control. This aligns with Theory Y (Douglas McGregor): most people want to do good work if they are respected, trusted, and given meaningful challenges.
  2. Empower teams with ownership Teams work best when they own the whole problem end-to-end, from idea to operation. Ownership gives autonomy and accountability, while purpose provides alignment. An empowered team doesn't just execute tasks but makes decisions and cares about outcomes.
  3. Motivation is intrinsic The best results in knowledge work come from intrinsic motivation, not external rewards or pressure. As Daniel Pink highlights in Drive, autonomy, mastery, and purpose are the real drivers of excellence. My role as a leader is to foster these conditions, not to rely on carrots and sticks. 
  4. Learning never stops Engineering and product work are constant processes of discovery. We optimize for fast feedback, safe experiments, and collective learning. Mistakes are not failures to hide but opportunities to grow. A learning culture is the foundation of adaptability. 
  5. Enable experiments, eliminate waste, make quality inevitable My role as a leader is to create conditions for safe experimentation while relentlessly removing what doesn't add value. But more fundamentally, I must change the system so that working with quality becomes the most natural, simplest, and fastest path. This means building strong foundations, aligning incentives, and creating space for learning where teams ask "What's the worst that could happen?" with confidence. When quality is inevitable rather than heroic, we create virtuous cycles where technical excellence enables bold experiments and meaningful impact.

These are my personal premises about engineering leadership and people management. They are not universal truths, but the foundations I rely on when building and leading teams. I believe that making these principles explicit helps create clarity, alignment, and better collaboration.


References:

Monday, April 07, 2025

The Phrases That Power My Leadership

Over the years, I’ve noticed that certain phrases have become central to how I lead teams. They're not just casual remarks—they're powerful tools that shape our culture and drive our decisions.

My leadership style leans more on intuition than rigid structure. But through reflection, I’ve realized I often return to the same phrases. These serve as mental shortcuts that influence how we work, decide, and collaborate.

"What’s the worst that could happen?" encourages experimentation without fear. It reflects a mindset of calculated risk-taking and a commitment to creating a safe space for innovation. This question only works if we can confidently answer, “Nothing serious—and we can fix it quickly.” That confidence comes from a strong foundation: technical excellence, sound design, automated testing, and continuous deployment. 


When we trust our systems and processes, experimentation becomes second nature. Then, questions like “What’s the next seemingly impossible goal we’ll accomplish?” don’t sound wild—they become grounded ambition. This mindset grows by breaking down complex problems and making thoughtful decisions step by step.

"Can we avoid doing it?" and "Can we achieve the same impact with fewer resources?" drive us toward efficiency. These align with Lean principles: reduce waste, maximize value. They help us cut complexity and focus on what truly matters. "What if we only had half the time?" forces us to prioritize and think about vertical slicing, ensuring we get feedback sooner. When technical quality is high, it’s easier to identify what’s unnecessary, simplify with confidence, and adapt quickly. Even a suggestion like “Let’s remove it and monitor the impact; we can restore it if needed” becomes a safe, low-risk move. In an environment with solid observability, metrics, and rollback capabilities, deletion becomes just another experiment. Another phrase I often use is, “Don't do anything I wouldn't do.” This encourages a sense of shared responsibility and ensures that everyone feels empowered to make decisions within the established boundaries and values of the team. It promotes trust and reinforces that we're all in this together.

These phrases go beyond individual decisions. They spark a positive feedback loop:

  1. Technical excellence builds speed and confidence.
  2. That enables experimentation, learning, and impact.
  3. That impact strengthens the team’s autonomy and trust within the organization.
  4. That trust leads to more investment—and more progress.

It’s a virtuous cycle. It doesn’t happen overnight, but once it begins, it changes everything.

In the end, these phrases work because they reflect a way of working built on ambition, focus, and care. We aim for innovation and execution while supporting each other along the way. And they work because there are teams who don’t just understand them—they live them every day.

This approach is also only possible thanks to the patience and insight of my colleagues. Thank you for joining me in exploring new ideas—and for steering us wisely when needed.

These are just a few of the phrases that guide my leadership. I’d love to hear the ones that guide yours. Feel free to share them in the comments below!

Related Articles (for more context and related principles):


Ultimately, these phrases—and the principles behind them—help build a culture of trust, innovation, and continuous improvement. It’s about empowering teams to do their best work and make a real impact.


Monday, December 26, 2022

My premises about software development

Updated on April 18, 2025: Refined and expanded article, with more complete explanations and a new point.

It is very important that, as a software development team, we share certain premises about software and software development. This allows us to work more efficiently and effectively, as we are all aligned in terms of our vision and goals. Over the past few years (2019–2024), I have continued to reflect on and refine these premises, finding further evidence and nuances in both my own experience and industry insights.

That is why I originally did an exercise in introspection to extract the basic premises that I almost unconsciously apply when I think about software and the process of developing it. Here I update those premises with additional context and lessons learned in recent years.

These are my premises for software system development:

  • Software development is a team activity: We cannot work in isolation but must collaborate with other developers, designers, and professionals to create a high-quality product. Effective product development requires cross-functional teamwork with shared ownership and trust. Truly empowered product teams take end-to-end responsibility from idea to delivery, which requires autonomy and direct interaction with users and customers. In practice, breaking down silos and enabling team ownership yields better outcomes and a happier team. Collaboration and shared context across roles are essential to navigate complex projects.
  • There is no real trade-off between quality and speed: The way to go fast is to maintain good quality. In the long run, low quality only ensures that we will go slower, as we’ll have to fix errors and deal with the fallout of technical debt. Neglecting quality creates a vicious cycle that drags down a team’s velocity. In contrast, investing in technical excellence (clean code, refactoring, testing, etc.) sets up virtuous cycles: achieving Continuous Delivery requires high code quality and small batch changes, which in turn enable faster, safer releases. Quality is what lets you move faster over time.
  • Software is a means to achieve an impact: We are not working just for the software itself, but to achieve an impact on the business or mission. Code is just a tool to deliver value. Software should be seen as a means to an end, not the end itself. The outcome (the impact on users or the business) is what matters, and extra code or features beyond that are liabilities to be minimized. We must keep this in mind when making decisions and prioritizing tasks, focusing on results over output.
  • Only about one-third of business ideas actually prove effective: We have to accept that many of our ideas will not produce the benefits we hope. Research at Microsoft found that only about one out of three shipped ideas or features actually improved the targeted metrics, and even Amazon sees less than 50% of ideas succeed. Therefore, we must optimize for learning and validation. This means constantly testing assumptions, measuring outcomes, and being willing to pivot or discard ideas that don’t prove valuable. Even the ideas that succeed typically require several iterations with real feedback to generate a positive impact.
  • When developing software-based systems, there is always a high degree of uncertainty: We must optimize for quick feedback and work iteratively and incrementally, always taking small, safe steps. Working in small, safe steps allows us to iterate quickly, reduce risks, and improve our understanding at each stage. Fast feedback beats big upfront plans in uncertain environments.
  • Software has a basal cost that must be taken into account (software can be considered a liability): Beyond the initial development effort of a feature, simply having that feature in the system incurs an ongoing cost. This Basal Cost continues until the feature is removed or the system is retired. Every feature or module adds complexity: it has to be understood by the team, maintained, integrated, and secured. When combined with the understanding that software is only a means to an end, it becomes clear that code is a liability as much as an asset. We should minimize the software we create to achieve the desired impact, delete unused code, and relentlessly manage complexity.
  • In software development, maintaining options and flexibility is valuable: To do this, it is essential to defer commitment and favor reversible decisions whenever possible. This reflects the Lean principle of deferring decisions until the last responsible moment. By postponing irreversible choices, we avoid premature lock-in and keep our design options open longer. This leads to simpler, more adaptable designs with lower accidental complexity.
  • Continuous Learning and Improvement are essential (NEW PREMISE): A software development organization must continuously learn and improve, or it will inevitably fall behind. The environment around us is always evolving, and standing still is equivalent to moving backward. Teams should invest in breaking vicious cycles (like unmanaged debt or poor quality slowing them down) and reinforcing virtuous cycles (like quality-focused small releases and continuous delivery) to sustain long-term success. Continuous improvement is not optional; it is a survival mechanism in modern software development.

These are my personal premises with respect to software development, and they are not necessarily universal principles. However, they have proven essential for working efficiently and effectively in the contexts I’ve been in (primarily product-centric software teams). I recognize that these premises may not apply in the same way in all contexts, but I perceive them as accurate in the environments in which I have worked.

Notably, many of these ideas have gained additional support in the industry through research and practice in recent years. Data from experiments confirm the need to focus on learning, and the DevOps community has demonstrated how quality enables speed. Other premises are bolstered by my own experience and observations of repeated patterns. In any case, I would love to continue sharing and contrasting these ideas with more colleagues in the software community.

Do you share these premises? Do you have additional premises or principles that guide you in software development? Does any of the above seem contradictory, or do they conflict with your own experiences? I’m eager to hear other perspectives – the discussion and continuous learning never stop in our field.


Related


Sunday, November 14, 2021

Improve or Die

A software development/product development organization should always be learning and improving.

When the organization is not learning or improving means that it is going backward, software development is a complex socio-technical system formed by several interrelated reinforcing loops. Some of the loops are positive (virtuous cycles) and some negative (vicious cycles), but the problem is that in such a complex system is difficult to find any balance, so in general, we are always moving. 

So the question is, in which direction? Are we learning and improving as a team, or are we dying or falling behind

Even if we managed to maintain a continuous flow of development with stable quality and speed (which is impossible), the whole ecosystem around us continues to improve and advance, so even in that case, we would be losing ground.

In general, the reinforcing loops are generated by things that compound with time or volume. 

For example, these are some things with negative compound effects: 

  • Complexity and basal cost of the product (cumulative features)
  • Quality problems.
  • Technical debt (if not managed).

Virtuous cycles examples:

  • Continuous delivery requires quality, requires small batches, removes silos, improves ownership, etc.
  • Product Team ownership requires autonomy, requires product instrumentation, requires learning from customers, generating more value, etc. 
  • etc

Vicious cycles examples:

  • Unmanaged technical debt, remove capacity from the team, generate more pressure, generate more technical debt, etc.
  • Accidental complexity makes difficult to understand the code, so generate more bugs, generate more pressure for the team, generate poor solutions with more accidental complexity, etc.
  • A bad deployment process generates frustration, so we tend to larger batches that are riskier, so have more problems, generate even more frustration, etc.
  • etc.

When we have several of these vicious cycles, it is easier than it seems to fall into a downward spiral from which we cannot get out.

So, are you investing in breaking the vicious cycles of poor quality, high resource usage, and unmanaged technical debt? Or are you investing in improving your virtuous cycles of working in small batches, with ownership and high quality?

Are you improving, or are you dying and falling behind?


And if the problem is that you don't know what a high-performance technology organization should look like, you are lucky; we now have information on how it should be (Accelerate book).


Related: