Archive

Software Delivery

The Budget-First Revolution: What Most Product Development Teams Don’t Know

In the world of product development, there are two fundamental approaches to budgeting: the cost-first approach (“How much will it cost?”) and the budget-first approach (“What can we get for our notional budget limit?”). Despite these being equally valid options, most organisations default to cost-first estimation simply because they’re unaware that budget-first is a legitimate alternative. This unconscious limitation of choice often leads teams down a path of unnecessary estimation complexity when a simpler approach might better serve their needs.

The Cost-First Approach: The Traditional Path and Its Pitfalls

The cost-first approach begins with a vision of what needs to be built and works backwards to determine the necessary budget. Whilst familiar to many organisations, this traditional estimation-based method comes with significant challenges and drawbacks:

The Estimation Fallacy

Studies consistently show that development estimates are notoriously inaccurate. The Cone of Uncertainty suggests that initial estimates can be off by a factor of 4x – or more – in either direction. Even with experienced teams, complex projects routinely exceed their estimated budgets by 50% or more.

Hidden Costs of Estimation

The process of creating detailed estimates consumes significant time and resources. Teams often spend weeks in estimation meetings, agreeing requirements, preparing documentation, and defending their numbers – time that could be spent actually building and delivering value.

The Planning Fallacy

Humans consistently display optimism bias in planning, underestimating the time and effort required for complex tasks. This psychological tendency, combined with pressure to provide “acceptable” estimates, leads to systematic underestimation.

Requirements Instability

The cost-first approach assumes requirements can be accurately defined upfront. In reality, requirements often change significantly during development as understanding evolves and market conditions shift. This makes initial estimates increasingly irrelevant as the project progresses.

Perverse Incentives

When estimates become commitments, teams face pressure to cut corners to meet arbitrary deadlines. This can lead to technical debt, reduced quality, and increased long-term costs. Additionally, teams may pad estimates defensively, reducing trust and transparency.

The #NoEstimates Movement

In response to these challenges, the #NoEstimates movement has emerged as a critique of traditional estimation practices. Pioneered by practitioners like Woody Zuill and Neil Killick, the movement questions the value of detailed upfront estimation in product development.

Core Principles of #NoEstimates:

  • Focus on delivering small, valuable increments rather than predicting future costs
  • Use historical data and throughput metrics instead of speculative estimates
  • Make decisions based on value and capacity rather than detailed predictions
  • Embrace uncertainty and adaptation rather than trying to eliminate them through planning

Alternative Metrics

Instead of detailed estimates, #NoEstimates advocates suggest focusing on:

  • Cycle time: How long it takes to complete work items
  • Throughput: How many items are completed per time period
  • Value metrics: Direct measures of business impact
  • Running tested features: Working software in production

The Budget-First Approach: Starting with Notional Limits

The budget-first approach flips the traditional model by starting with a notional budget limit and determining what can be delivered within those constraints. Whilst this approach has gained popularity with the rise of agile development and lean startup principles, it remains surprisingly underutilised. Many teams continue with tortuous estimation processes simply because they don’t realise they have a choice.

Understanding Notional Budget Limits

The term “notional budget limit” is crucial here – it represents the realistic financial boundaries within which the team must operate. This isn’t about arbitrary restrictions, but rather about acknowledging the actual financial constraints that exist in most organisations. These limits might come from:

  • Annual departmental budgets
  • Quarterly funding allocations
  • Project portfolio constraints
  • Market-driven price points for the final product

Working Within Known Constraints

Rather than spending time estimating costs that may or may not fit within available budgets, teams start with the known financial constraints and work backwards. This creates a more focused conversation about:

  • What features provide the most value within the budget limit
  • How to phase delivery to match funding cycles
  • Where to make strategic trade-offs
  • How to maximise return on the available investment

Prioritisation is Key

Rather than exhaustively documenting all possible features, teams focus on identifying and prioritising the most crucial functionality. This often leads to better-focused products that deliver core value more efficiently.

MVP Definition

Teams work backwards from the notional budget limit to define a Minimum Viable Product (MVP) that fits within financial constraints whilst delivering essential functionality. This forces tough but valuable conversations about what features are truly necessary versus nice-to-have.

Innovation Through Clear Constraints

Understanding the notional budget limit upfront often drives more creative solutions. Teams focus their innovation efforts within known parameters rather than generating ideas that may prove financially unfeasible.

Why Teams Don’t Choose Budget-First

Understanding why budget-first remains underutilised can help organisations make more conscious choices about their approach:

Cultural Inertia

Many organisations have deeply ingrained practices around estimation and budgeting that are rarely questioned. The very idea that there might be an alternative to detailed estimation often comes as a surprise.

Misunderstanding of Control

There’s a common misconception that detailed estimates provide more control over development outcomes. In reality, budget-first approaches often provide better control by forcing early decisions about priorities and trade-offs.

Fear of Commitment (Lack of Trust)

Some organisations avoid stating budgets upfront, believing it will lead to teams consuming the entire budget regardless of need. This fear often leads to the more wasteful practice of extensive estimation exercises.

Procurement and Governance Requirements

Many organisations believe their governance processes require detailed estimates. In reality, most governance requirements can be satisfied through budget-first approaches with appropriate documentation of assumptions and priorities.

Choosing the Right Approach

The choice between cost-first and budget-first approaches often depends on several factors:

When to Use Cost-First

  • Regulatory compliance projects with non-negotiable requirements
  • Mission-critical systems where functionality cannot be compromised
  • Projects with well-understood requirements and clear technical paths
  • Organisations with flexible budgets and focus on comprehensive solutions

When to Use Budget-First

  • Startups and new product initiatives with limited funding
  • Innovation projects where learning and adaptation are crucial
  • Organisations with strict budget cycles or financial constraints
  • Projects where time-to-market is a primary concern

Making the Choice Conscious

To move towards more effective budgeting approaches, organisations might choose to:

Question Default Practices

Before automatically responding to the question “How much will it cost?”, teams might choose to explicitly consider whether a budget-first approach might be more appropriate.

Educate Stakeholders

Help decision-makers understand that budget-first is a valid and often more effective approach. This includes explaining how it can lead to better outcomes and more efficient use of resources (i.e. lower costs, quicker time to market).

Start Small

Consider piloting budget-first approaches on smaller projects where the stakes are lower and resistance to change may be less intense.

Success Factors for All Approaches

Regardless of the chosen methodology, certain factors are crucial for success:

Clear Communication

All approaches require transparent communication about constraints, whether they’re financial or functional. All stakeholders may choose to understand and agree to the chosen approach and its implications.

Realistic Expectations

Teams may choose to be honest about what can be achieved, whether working within a fixed budget or estimating costs. Over-optimism in either approach leads to disappointed stakeholders and stressed teams.

Regular Review and Adjustment

All approaches benefit from regular checkpoints to assess progress, adjust plans, and ensure alignment with business objectives Cf. Tom Gilb’s Mountain Goat principle). This includes being willing to make tough decisions about scope, quality, or additional funding when necessary.

Conclusion

Whilst the cost-first approach remains common in many organisations, this is often due to habit rather than conscious choice. The emergence of budget-first thinking, which starts with notional budget limits, reflects a broader shift toward more adaptive, value-focused approaches to development.

The key is not just to choose between approaches, but to make that choice consciously rather than defaulting to traditional estimation methods out of habit. By acknowledging that working within notional budget limits is a valid starting point, organisations can make better choices about how they approach budgeting and delivery.

Success in modern development invites questioning of traditional practices and being willing to adopt approaches that might initially feel uncomfortable. Whether through budget-first methods, #NoEstimates practices, or hybrid approaches, organisations have more options than they often realise for moving beyond the limitations of traditional cost-first estimation.

The Inevitable Disaster: Management’s Poison Touch in Software Development

The Undeniable Truth: Management Always Makes It Worse

In the world of software development, one truth stands above all others: every single management intervention, without exception, makes things worse. This isn’t an exaggeration or a pessimistic view – it’s the cold, hard reality that developers face – and that I’ve personally seen time and time again – every day. Management, in its infinite wisdom, has a reverse Midas touch: everything it touches turns to doodoo.

The Destruction Derby: How Management Ruins Everything

1. Process Pollution

When management meddles with development approaches, the result is always the same: a bureaucratic nightmare that strangles productivity.

Example: A once-streamlined workflow becomes a kafka-esque labyrinth of checkpoints, approvals, meetings, and pointless documentation, turning an hour’s work into a week-long ordeal.

2. Tool Tyranny

Every tool foisted upon developers by management inevitably becomes an instrument of torture, with JIRA standing out as the crown jewel of developer torment.

Example: JIRA, the project management tool from hell, crapped upon teams by managers who mistake micromanagement for productivity. What was once a simple task of writing code becomes a Kafkaesque nightmare of logging hours, updating statuses, and navigating through a labyrinth of epics, stories, and sub-tasks. Developers spend more time wrestling with JIRA’s byzantine interface than actually coding, turning a day’s work into a weeks-long ordeal of clickety-click busywork. The result? A beautiful illusion of control for managers, and a soul-crushing reality for developers who watch their productivity vanish into the abyss of over-engineered management.

3. Team Toxification

Management’s attempts to “improve” team dynamics invariably poison the well of camaraderie and fellowship.

Example: A so-called team-building exercise that pits developers against each other, destroying trust and turning a once-cohesive unit into a den of paranoia and backstabbing.

The Laws of Managerial Destruction

The Metric Massacre

Every metric introduced by management becomes a weapon of mass dysfunction. No exceptions.

Example: Story point targets that turn thoughtful estimation into a farce, with developers inflating numbers just to keep management off their backs.

The Communication Catastrophe

When management tries to “improve communication,” it always results in an avalanche of noise that buries any actual signal.

Example: A new “open communication” policy that floods inboxes with useless updates, ensuring that important messages are lost in a sea of managerial spam. In my past, Sun Microsystems was a classic example of this.

The Expertise Annihilation

The more confidently management intervenes in technical matters, the more spectacular the ensuing disaster.

Example: A clueless executive’s insistence on using blockchain for a simple CRUD application, leading to a bloated, unusable system that solves no problems while creating a hundred new ones.

The Motivation Massacre

Every single management initiative aimed at “boosting morale” is a guaranteed morale killer.

Example: A “fun” gamification system for code commits that turns professional developers into point-chasing automatons, stripping away any remaining job satisfaction.See also: the Cobra Effect.

The Innovation Graveyard

Management’s efforts to “foster innovation” are where good ideas go to die.

Example: An “innovation lab” that’s really just a purgatory for creative thinking, where ideas are committee’d to death before they can see the light of day.

The Inescapable Conclusion: Management Must Go

As we sift through the wreckage of countless failed management interventions, one inescapable conclusion emerges: in software development, management is not just useless – it’s actively toxic. There is not a single documented case, anywhere in the history of software development, where a management initiative has improved things. Not one.

This isn’t about bad managers or poor implementation – it’s about the fundamental incompatibility between traditional management thinking and the reality of software development. The chasm between management’s perception and the actual work of creating software is so vast that every attempt to bridge it only makes things worse.

The solution is as clear as it is radical: the complete and total removal of management from software development. No more “agile coaches,” no more “scrum masters,” no more “project managers.” Just developers, doing what they do best, free from the poisonous touch of management.

The Path Forward: A Management-Free Utopia

The future of software development lies not in “better” management, but in no management at all. Only by excising the cancer of managerial meddling can we hope to unleash the true potential of software teams.

Imagine a world where developers are free to organise their own work, choose their own tools, and communicate in ways that actually make sense for them. A world where innovation isn’t stifled by bureaucracy, where motivation comes from the work – from meeting folks’ needs –  itself rather than arbitrary metrics, and where expertise is valued over authority.

This isn’t a pipe dream – it’s the only way forward. The age of management in software development is over. It’s time to embrace the chaos, trust in the expertise of developers, and finally bid farewell to the destructive force that is management in software development.

The best thing management can do for software development is simple: get out of the way, and stay out. Only then can we break free from the cycle of perpetual deterioration that has plagued our industry for far too long.

The Elusive Quest for “Better Software”

The Mirage of “Better”

In the relentless pursuit of technological advancement, the software industry has long been fixated on a nebulous concept: “better software”. But what if we’ve been chasing a mirage? What if our definition of “better” has been fundamentally flawed from the start?

Deconstructing the ‘Better’ Fallacy

The Metrics Trap

Traditionally, we’ve measured software quality through a narrow lens:

  • Speed and performance
  • Feature richness
  • UI sophistication
  • Reliability and uptime

While these metrics have their place, they paint an incomplete picture. They’re the equivalent of judging a book solely by its cover and page count, ignoring the depth and relevance of its content.

Introducing the Needsscape™: A Radical Paradigm

To truly elevate software development, we need to shift our focus to what I call the Needsscape™—a multidimensional terrain that maps the intricate and ever-evolving web of needs, desires, and pain points across all the Folks That Matter™.

Navigating the Needsscape™

The Needsscape™ encompasses four critical dimensions:

  1. Functional Needs: The tangible, practical requirements of the software.
  2. Emotional Needs: The often-overlooked psychological and emotional impact on all the Folks That Matter™.
  3. Contextual Needs: How the software fits into and enhances existing systems, product lines, ecosystems and workflows.
  4. Hidden Needs: The unspoken, sometimes subconscious desires that, when addressed, can transform folks’ experiences.

The Forgotten Stakeholders: Expanding Our Horizon

When we talk about the Folks That Matter™, our focus often narrows to end-users and perhaps upper management. But the Needsscape™ reveals a far more complex and dynamic tapestry of individuals – and groups  -whose needs we might choose to consider:

  • Development Teams: How does the software architecture impact their work-life balance and professional growth?
  • Support Staff: Are we creating systems that empower them to provide exceptional service?
  • Operations Teams: How does our software design affect system maintenance and scalability?
  • Sales and Marketing: Does the product align with market needs and tell a compelling story?
  • Diverse End-Users: How can we create inclusive solutions that serve users across different abilities, cultures, and contexts?

From Feature Bloat to Meaningful Innovation

The industry’s obsession with feature accumulation has led us astray. We’ve created bloated, complex systems that often solve the wrong problems—or worse, create new ones.

The Power of Subtraction

Sometimes, the most significant improvements come not from adding features, but from ruthlessly eliminating unnecessary complexity. By deeply understanding the Needsscape™, we can:

  • Identify and remove features that add cognitive load without proportional value.
  • Streamline workflows to match natural human processes.
  • Create intuitive interfaces that feel “invisible”, allowing users to focus on their goals rather than the tool itself.

Empathy as a Core Competency

The most critical skill in navigating the Needsscape™ isn’t technical prowess—it’s empathy. We might choose to cultivate a deep, almost intuitive understanding of our stakeholders’ lived experiences.

Practical Empathy in Action

  • Immersive Observation: Go beyond user interviews. Spend days shadowing different stakeholders, experiencing their frustrations and victories firsthand.
  • Cross-Functional Empathy Workshops: Bring together diverse teams to role-play different stakeholders, fostering a holistic understanding of the Needsscape™.
  • Continuous Feedback Loops: Implement systems for ongoing, qualitative feedback that captures the evolving nature of stakeholder needs and the dynamics of the Needsscape™.

Redefining Success: New Metrics for a New Era

If we’re to truly create “better” software, we need metrics that reflect the multidimensional nature of the Needsscape™:

  • Stakeholder Flourishing Index: Measure how the software contributes to the professional and personal growth of all the Folks That Matter™.
  • Ecosystem Impact Score: Evaluate how the software enhances or disrupts existing workflows and systems.
  • Cognitive Load Reduction Metric: Quantify how much mental effort the software saves across different user groups.
  • Adaptability Quotient: Assess how easily the software can evolve to meet changing needs without accumulating technical debt.

The Path Forward: A Call to Action

Creating truly better software isn’t about chasing the latest technological trends. It’s about fundamentally reimagining our approach to development and truly serving the Folks That Matter™,:

  1. Embrace the Needsscape™: Make it a core part of your development philosophy and process.
  2. Cultivate Radical Empathy: Invest in developing teams’ ability to deeply understand and relate to all the Folks That Matter™.
  3. Value Subtraction: Celebrate the removal of unnecessary complexity even more than the addition of new features.
  4. Redefine Metrics: Implement holistic success measures that reflect the true impact of your software.

By shifting our focus from arbitrary notions of “better” to a nuanced understanding of the Needsscape™, we can create software that doesn’t just impress with its technical specifications, but profoundly improves the lives of all it touches. This is the true meaning of innovation—and the future of software development.

What Has Violence To Do With Software Development?

We often focus on technical skills and cutting-edge technologies. However, there’s a critical factor that frequently goes overlooked: the impact of management styles on cognitive performance. Today, we’ll explore how violent management practices can severely undermine the very foundation of software development productivity.

Understanding Violence in the Workplace

Defining Violence

To grasp the full scope of this issue, let’s first recap our understanding of violence. Here’s my definition from some years back:

Violence is any act or behaviour that harms, or threatens to harm, another person’s physical, psychological, emotional or cognitive well-being.

In the context of software development, this definition encompasses far more than physical aggression. It includes psychological coercion, emotional manipulation, and practices that impair cognitive function and Cf. Amygdala hijack).

The Many Faces of Violent Management

Coercion and Fear

Many managers, often unintentionally, employ tactics that create an atmosphere of fear:

  • Threats and implied threats of job loss, sidelining, or demotion
  • Unrealistic deadlines with implied negative consequences
  • Public criticism or shaming for mistakes

These approaches, while sometimes viewed as ‘motivational’, are forms of violence that undermine the cognitive environment essential for effective software development.

Guilt and Obligation

Another subtle form of violence in management involves manipulating developers’ sense of duty:

  • Excessive overtime – whether paid or unpaid – portrayed as ‘commitment to the team’
  • Guilt-tripping for taking time off or prioritising work re: work-life balance
  • Creating a culture where personal sacrifices are expected and normalised

The Cognitive Cost of Violent Management

Impairment of Essential Skills

Software development is fundamentally a cognitive task. It requires high levels of concentration, problem-solving ability, and creativity. Antithetical management practices directly impair these essential functions:

  • Stress-induced reduction in working memory capacity
  • Decreased ability to make complex decisions under pressure
  • Impaired focus and concentration due to constant fear or anxiety

The Creativity Killer

Innovation and creative problem-solving are at the heart of software development. However, in an environment of fear and coercion:

  • Developers are less likely to propose novel solutions
  • Risk-taking, essential for innovation, is stifled
  • The focus shifts from creating quality code to avoiding punishment or even mere criticism

The Need for Cognitive Safe Spaces

Nurturing the Developer’s Mind

To counter the detrimental effects of violent management, organisations might choose to prioritise creating ‘cognitive safe spaces’. These are environments where:

  • Developers feel psychologically safe to take risks and make mistakes
  • Open dialogue is encouraged without fear of reprisal
  • The focus is on learning and growth rather than blame and punishment

Elements of a Cognitive Safe Space

  1. Psychological safety: Team members feel comfortable expressing ideas and concerns
  2. Learning culture: Challenges are seen as opportunities for learning
  3. Clear communication channels: Open, honest dialogue is encouraged at all levels
  4. Balanced workload: Realistic expectations that allow for deep, focused work

The Flourishing of Productivity in Safe Spaces

Unleashing Cognitive Potential

In environments free from the dark shadow of violence:

  • Creativity blossoms, leading to innovative solutions
  • Problem-solving abilities are enhanced
  • Developers are more engaged and invested in their work

Collaborative Synergy

When minds are free to connect without fear:

  • Knowledge sharing becomes the norm
  • Cross-pollination of ideas leads to breakthrough innovations
  • Team problem-solving capabilities are exponentially increased

Long-term Benefits of Cognitive Safety

Sustainable Productivity

Environments that nurture cognitive function lead to:

  • Increased job satisfaction and reduced burnout
  • Higher retention rates of skilled developers
  • Consistent, high-quality output

Building a Positive Reputation

Companies known for their cognitive safe spaces:

  • Attract top talent in the industry
  • Foster loyalty among their development teams
  • Often become industry leaders in innovation

Implementing Cognitive Safe Spaces

To transition from violent management to a culture that nurtures cognition:

  1. Leadership training: Educate managers – and developers! – on the importance of psychological safety and the connection with cognitive function
  2. Regular feedback loops: Implement systems for developers to safely voice concerns
  3. Stress reduction initiatives: Offer programmes that help manage work-related stress
  4. Collaborative work structures: Encourage pair programming, ensemble programming and mentorships
  5. Recognition of cognitive effort: Acknowledge the mental challenges of development work
  6. Psychology: Raise the profile of psychology and it’s relevance to the software development workplace

Conclusion

The link between violent management practices and reduced productivity in software development is clear, but so often ignored. By recognising the various forms of violence in the workplace and actively working to create nonviolent safe spaces, organisations can unlock the fuller potential of their development teams. In an industry where cognitive performance is paramount, fostering an environment free from fear, coercion, and manipulation isn’t just ethical—it’s a crucial strategy for success.

Remember, the goal is not just to produce code, but to create an environment where developers can thrive, innovate, and push the boundaries of what’s possible. By prioritising cognitive safety, we pave the way for more productive, innovative, and ultimately more successful software development.

The Why of FlowChain: Deliberate Continuous Improvement

In my career, working with hundreds of companies, I’ve almost never seen organisations* take a truly deliberate approach to continuous improvement. It’s nearly always treated as an afterthought or add-on to business-as-usual (BAU). But real transformation requires making continuous improvement an integral and core part of daily work. This is the “why” behind FlowChain – enabling deliberate, in-band continuous improvement.

In other words, applying the same disciplines from product development, delivery, etc. to the business (sic) of delivering continuous improvements  – continuously improving the way the work works.

What Is FlowChain?

So what is FlowChain? At its core, it is a system for managing flow – both the flow of outputs and the flow of improvements to the way the work works, concurrently and by the same means. And by “flow”, I mean the steady progress of work from request to completion through all steps in a process. Flow is optimised when the right work is happening at the right time by the right people. Roadblocks, delays, and waste are minimised or eliminated.

Flow

Optimising flow delivers the following benefits:

  • Increased productivity – less time wasted, more work completed
  • Improved quality – fewer defects, rework minimised
  • Better customer service – faster response times, reliability
  • Higher employee engagement – less frustration, more joy

But achieving flow requires continuous improvement. Problems must be made visible. Waste must be reduced iteratively. Roadblocks must be cleared continuously.

This is why FlowChain incorporates improvement into its regular rhythm. Each cycle follows a deliberate sequence:

  • Plan – Select and sequence the upcoming work.
  • Execute – Complete the work while tackling issues.
  • Review – Analyse completed work and identify improvements.
  • Adjust – Make changes to improve flow.

Unlike most continuous improvement efforts – that are separate from BAU – FlowChain makes improvement an integral in-band activity. The rapid cycles provide frequent opportunities to reflect, gain insights, and act.

Compounding Benefits

Over time, the compounding benefits are immense. Teams develop a “flow habit”, where improving flow becomes second nature. Powerful capabilities like root cause analysis, A3 problem-solving, improvement katas, and change management are honed.

In my experience, this deliberate approach is transformative. Teams gain tremendous agency to systematically improve their own flow. The organisation as a whole cultivates a culture of continuous improvement. And customers experience ever-better service and responsiveness.

The “why” of FlowChain is simple – create focus, visibility, accountability, and agency to drive continuous improvement. The results – ever better flow, reduced waste, and sustainable transformation. Deliberate, in-band continuous improvement stops being an aspiration and becomes a reality.

*Ask me about the exception.

Are Managers Killing Their Golden Geese?

Cognitive Function Rules

Cognitive function encapsulates the mental processes needed for problem-solving, abstract thinking, and quick decision-making. In the realm of software development, high cognitive function is indispensable for understanding complex algorithms, creating efficient code, delivering quality, and solving intricate problems.

Why Does Cognitive Function Matter?

When cognitive function is at its peak, developers can perform their tasks not just quickly but also effectively. It enables them to come up with innovative solutions, debug issues proficiently, and contribute meaningfully to a project’s success.

How Do Managers Disrupt Cognitive Function?

Routine managerial practices like frequent check-ins, status reports, micromanagement, and unclear objectives can negatively impact a developer’s cognitive function. Added to this, loaded work schedules and harsh deadlines contribute to stress, which further degrades cognitive performance.

What About Toxic Behaviour?

Abusive and toxic conduct from managers goes beyond disrupting cognitive function. This behaviour often leads to severe emotional stress, causing long-term harm – including brain damage – that manifests as burnout, poor performance, and staff turnover.

What’s the Consequence?

When cognitive function suffers, the ripple effect is felt throughout the team and the organisation. There’s a decline in product quality, an increase in mistakes, and a noticeable lag in delivery timelines. In such a scenario, managers are essentially killing the very geese (developers) that lay the golden eggs (software).

Is There a Remedy?

Creating a more nurturing work environment can help. Managers might choose to adopt practices that allow for focused work, respect individual needs, and most importantly, eliminate toxic and abusive behaviours.

Will Change Happen?

The ball’s in the managers’ court. The cognitive well-being of their software developers—and by extension, the quality and success of their own wellbeing—depends on how they choose to adapt their management styles.

Improving Without Measuring

NoRuler

The Mirage of Measuring Productivity

Most organisations regard metrics as the Holy Grail of productivity. But what if we’re wasting our time, trapped in a Sisyphean cycle of measuring, adapting, and then measuring again, without achieving improvement? Metrics often mislead us. The more relevant question is: How do we truly make a difference?

The Complexity of Social Systems in Software Development

To get to the heart of the issue, we have to confront the chaos that comes with human beings working together. People aren’t variables in an equation; they’re living, breathing agents of unpredictability. In such an environment, even if we find a metric that looks promising, the inherent complexity could render it meaningless.

Deming’s Caveat: “The Most Important Figures are Unknown or Unknowable”

Before we take another step down the rabbit hole of productivity metrics, let’s pause to reflect on a pertinent insight from W. Edwards Deming, the father of modern quality management. He stated,

The most important figures that one needs for management are unknown or unknowable.

If one of the most influential minds in quality management and productivity warns us against an over-reliance on metrics, it’s worth taking note.

Why Metrics Often Fail in Social Systems

Metrics tend to misfire when applied to the inherently chaotic world of human interaction. It’s not a mechanical system with predictable outcomes; it’s more of an organic entity with complex, non-linear interactions. So, when metrics disappoint, it’s not the numbers that are at fault but our misplaced expectations of their ability to capture reality.

Turning to Systemic Improvements: The Untold Chapter

If we heed Deming’s advice, our focus shifts from trying to measure the immeasurable to creating conditions for productivity to flourish. When we step back from the Sisyphean task of trying to pin down productivity with metrics, as per Deming’s counsel, we make room for a paradigm shift.

Instead of fixating on measured outcomes, the focus turns towards the fertile ground from which these outcomes naturally emerge. Here’s how this shift fundamentally changes our approach to productivity. (Cf. Quintessence).

Systems Thinking: The Big Picture

Deming was a strong advocate for systems thinking. This perspective urges us to see the workplace not as a collection of isolated variables but as a holistic system. Individual performances are interrelated, affected by the entire system, including leadership styles, workplace culture, communication pathways and a host of other memes. By optimising the system as a whole, we inherently create conditions for better productivity.

Quality of Interactions Over Quantity of Output

If we’re not bogged down by the numbers, we can invest time and energy into what really matters, such as the quality of interactions among team members. High-quality interactions naturally lead to high-quality output. Team members who communicate clearly, collaborate effectively, and feel psychologically safe are more likely to be productive.

By heeding Deming’s advice, we engage in a more holistic, humane, and, ironically, effective approach to boosting productivity. We may not have a neat vanity metric to showcase in the next board meeting, but the signs will be everywhere—in the engagement of the team, the quality of the work, and the satisfaction of your clients.

Improving Without Measuring: Sounds Like Heresy, Doesn’t It?

Here’s the part where some people might think we’re heading into taboo territory. How do we know we’re making progress if we’re not measuring it? The key is to focus on systemic improvements that are intuitively beneficial, such as:

  • Surfacing and reflecting on collective assumptions and beliefs
  • Attending to folks’ needs
  • Enhancing communication channels
  • Making things visible
  • Reducing work-in-progress
  • Emphasising learning and personal development
  • Promoting psychological safety

By attending to these areas, we’re likely moving in the right direction, even if we can’t quantify it.

Feedback Loops: Your New Best Friend

Feedback loops provide insights without the narrow focus of traditional metrics. They allow teams to observe patterns, adapt, and continuously learn. These can range from daily stand-ups to sprint reviews, to customer feedback sessions. The idea is to keep the feedback continuous and actionable.

Holistic Approaches: Taking a Cue from Organisational Psychotherapy

Improving productivity in complex systems requires less of a mechanical approach and more of a therapeutic one. Techniques like organisational psychotherapy aim to uncover underlying issues at the collective subconscious level. By addressing these foundational aspects, we’re more likely to see a genuine shift in productivity.

So, Are We Moving the Needle?

The perennial question still stands: How do we know we’re improving? But maybe we’ve been asking the wrong question. The more relevant question is: Are we creating an environment where improvement is not just possible but inevitable? And what does that environment look like?

So, let’s leave behind the vanity of metrics and embrace the nuanced, often messy journey of actual improvement. The numbers may not make it to a glitzy PowerPoint presentation, but the positive change will be palpable. And isn’t that what really matters?

The Deming Way to Measuring Software Developer Productivity

Many software folks pay lip service to Bill Deming and his work. Few if any pay any attention to the implications. Let’s break the mould and dive into how the great man himself might look at software developer productivity (a subset of collaborative knowledge worker productivity more generally).

This isn’t just a thought experiment; it’s an invitation to rethink our existing assumptions and beliefs about productivity.

Why Traditional Metrics Don’t Cut It

If Deming could peer over our shoulders, he’d likely be aghast at our fascination with shallow metrics. Lines of code? Bugs fixed? DORA? SPACE? These are mere surface ripples that fail to delve into the depths of what truly constitutes productivity. Deming was a systems thinker, and he’d want us to look at productivity as an outcome of a complex system. It’s influenced by everything from the quality of management practices to the clarity of project goals, and yes, even the standard of the coffee in the break room.

Aside 1

Let’s not get too hung up on staff productivity and the measurement thereof.

Deming’s First Theorem states that:

“Nobody gives a hoot about profits.”

A corollary might be:

“Nobody gives a hoot about software developer productivity.”

Which, drawing on my 50+ years experience in the software business, rings exceedingly true. Despite all the regular hoo-hah about productivity. Cf. Argyris and espoused theory vs theory in action.

Aside 2

While we’ve on the subject of measurment, let’s recognise that measuments will only be valid and useful when specified by and collected by the folks doing the work. I’ve written about this before, for example in my 2012 post “Just Two Questions“.

Aside 3

Let’s remember that the system (the way the work works) accounts for some 95% of an individual’s productivity. Leaving just 5% that’s a consequence of an individual’s talents and efforts. This makes it clear that attempting to measure individual productivity, or even team productivity, is a fool’s errand of the first order.

Here’s the Deming Approach

So, how would the statistician go about this? Hold on to your hats, because we’re diving into an eight-step process that marries statistical rigour with psychology and humanistic care.

1. Understand the System

First things first, get to grips with the holistic view. Understand how a line of code travels from a developer’s brain to the customer. This involves understanding the various elements in the software development lifecycle and how they interact.

2. Define Objectives

Random metrics serve no one. Deming would urge us to link productivity measurements to broader business objectives. What’s the end game? Is it faster delivery, better quality, or increased customer satisfaction?

3. Involve the Team

The people on the ‘shop floor’ have valuable insights. Deming would never neglect the developer’s perspective on productivity. Involving them in defining productivity criteria ensures buy-in and better data accuracy.

4. Data Collection

We’ve got our objectives and our team’s perspective. Now it’s time to roll up our sleeves and get to work on data collection. But this is Deming we’re talking about, so not just any data will do. The focus will be on meaningful metrics that align with the objectives we’ve set.

5. PDSA Cycle

Implementing the Plan-Do-Study-Act (PDSA) cycle, any changes aimed at boosting productivity would be introduced in small, incremental phases. These phases would be assessed for their effectiveness before either full implementation or going back to the drawing board.

6. Feedback Loops

You’ve made changes; now listen. Feedback from developers, who can offer a real-time response to whether the changes are working, is invaluable.

7. Regular Reviews

Productivity isn’t a static entity. It’s a dynamic component of a system that’s always in flux. Regular reviews help recalibrate the process and ensure it aligns with the ever-changing landscape.

8. Leadership Commitment

Finally, if you think increasing productivity is solely a developer’s job, think again. The leadership team must be as committed to this journey as the developers themselves. It’s a collective journey toward a common goal.

The Long Game

Deming never promised a quick fix. His was a long-term commitment to systemic improvement. But the fruits of such a commitment aren’t just increased productivity. You’re looking at more value for your business and greater satisfaction for both your developers and customers. So, let’s stop paying lip service to Deming and start actually embracing his philosophy. After all, a system is only as good as the assumptions and beliefs that shape it.

Maximising the Amount of Work Not Done: The Power of Attendants in Tech Teams

The world of technology is evolving rapidly, and to keep pace, we must continually reassess how we approach our work. A concept gaining popularity in tech leadership circles is the idea of “Maximising the Amount of Work Not Done.”

Counterintuitive

While this may sound counterintuitive, it is a strategic move towards efficiency and streamlined operations. The role of the “Attendant” embodies this principle. Let’s delve deeper.

The Attendant’s role is less focused on coding intricacies and more on recognising and satisfying the needs of various stakeholders – customers, fellow team members, other teams within the organisation, senior management, and the organisation as a whole. The attendants’ goal? To find the simplest and most efficient solutions to meet these needs.

In doing so, Attendants embody the principle of maximising the amount of work not done. Here’s how:

  1. Focusing on What Really Matters: In any project, there can be a multitude of potential features, tweaks, and enhancements. However, not all are equally important or add significant value. Attendants prioritise based on the actual needs of stakeholders, focusing efforts only on work that meets genuine needs. This eliminates unnecessary tasks and promotes efficiency.
  2. Streamlining Communication: Miscommunication can lead to rework and delays. Attendants foster clear, effective communication among various parties, ensuring everyone understands the goals and requirements from the start. This reduces the chance of misunderstandings that can lead to unnecessary work and rework.
  3. Advocating for Simplicity: Attendants champion the philosophy that simplest is often best. They seek to develop solutions that meet everyone’s needs effectively without unnecessary complexity. This can drastically reduce development time, cut down on potential bugs, and increase the speed of product delivery.
  4. Preventing Over-Engineering: By maintaining a sharp focus on stakeholders’ needs and the simplest ways to meet them, Attendants help prevent over-engineering— the practice of making a product more complicated and/or feature-rich than necessary. This not only saves time and resources but also results in products that are easier to use and maintain.

Game Changer

Embracing the Attendant’s role and their commitment to maximising the amount of work not done can lead to more efficient, streamlined operations. It brings a focus on delivering value quickly and eliminating tasks that do not directly contribute to meeting stakeholders’ needs. In a rapidly evolving tech landscape, this approach is a game-changer.

“Not Everybody Matters”: A Bold Approach to Streamlining Software Development

💡 Need to unlock your team’s full potential and supercharge your software development process? Uncover the game-changing strategy behind embracing “Not Everybody Matters”, and learn how mastering the Needsscape and understanding the Cost of Focus can catapult your project to success! 🎯💥🚀

➡ In the world of software, service and product development, catering to every stakeholder’s needs can be both challenging and resource-intensive.

Embracing the idea that “Not Everybody Matters” can lead to more effective development processes by prioritising the most critical needs and stakeholders. By focusing on the essential elements of a project, teams can allocate resources more effectively and reduce development time.

The Needsscape
The Needsscape is a concept that helps identify and dynamically prioritise the needs of various stakeholders. By carefully tracking the Needsscape, development teams can determine which needs have the most significant impact at any given moment, and align their efforts accordingly. This approach acknowledges that not all needs are equally important, and allocating resources to meet every need regardless of relative impact leads to increased costs and inefficiencies.

The Cost of Focus
The Cost of Focus is the trade-off that occurs when concentrating on one are over another. By acknowledging that “Not Everybody Matters,” development teams can make informed decisions about where to invest their time, effort, and resources. This approach might involve prioritising features that have the highest value for the majority of users or focusing on the needs of specific subsets of the audience.

The concept of “Not Everybody Matters” in software development is a bold approach that encourages teams to prioritise the most critical needs and stakeholders by leveraging the Needsscape and understanding the Cost of Focus. By doing so, they can streamline the development process, maximise the value delivered, and ultimately create more successful software products.

Software Development: It’s Not Even Slightly About Tech Skills and Coding Practices

💡 What’s the undervalued secret sauce of software success? You’re in for a wake-up call as we reveal the overlooked ingredients that make or break software success in the business world.

➡ Blimey, it’s no surprise that most execs – those few that are even slightly interested in software development – reckon it’s all about tech skills and coding practices. But I’ll tell you, there’s more to this picture than meets the eye. Sure, being a dab hand at coding is somewhat useful, but in the context of business operations, it’s just the tip of the iceberg.

You see, the nitty-gritty of software development, especially in a business setting, also involves top-notch communication, teamwork, and adaptability.

And let’s not forget, building strong interpersonal relationships is a piece of cake for no one, but it’s a skill developers need to master to keep things from going pear-shaped.

A good understanding of the customer’s needs and the company’s goals is also crucial. After all, you can’t score a winner if you don’t know where the goalposts are. So, execs might choose to realise that there’s more to software development than just cranking code. And much more to hiring than the recruitment of code toads.

A successful software development team is the whole package. It’s not just about having a bunch of coding whizzes; it’s also about fostering a culture where everyone’s on the same page, working together as a community to bring work to fruition. Otherwise, businesses might find themselves up a creek without a paddle.

Software Development: Culture Shift is More Vital Than Any Coding Practices

With 50+ years experience in the software development industry, I’ve come to understand that the key to progress in this field lies not in technological advancements, but in cultural changes.

Alan Kay’s concept of obliquity highlights the idea that the most effective way to achieve a goal is not always by pursuing it directly, but rather by approaching it from a different angle. In the context of software development, this means that our focus might better be placed on changing the underlying culture that shapes how software is created and delivered.

The current state of the industry is far from optimal, with over 90% of Agile adoptions failing to deliver the promised benefits. The pressure to meet unrealistic deadlines, the lack of whole-systems thinking, and the absence of a learning culture all contribute to the failure of Agile initiatives.

A critical aspect of cultural change is the need to embrace failure. Failure is not something to be feared, but rather an opportunity to learn and grow. It is through failure that we discover what works and what doesn’t, and can adapt our approach accordingly. A culture that embraces failure as a natural part of the learning process is one that is more likely to succeed in the long run.

In addition, we must move away from the traditional focus on individual performance metrics and instead measure success based on the collective achievements of the whole organisation. This means redefining success as the ability to deliver high-quality software that meets the needs of the business and its customers. It also means recognising and rewarding collaborative behaviour, rather than individual contributions.

Finally, we must recognise that cultural change is a continuous process, not a one-time event. It requires ongoing effort and commitment, and must be reinforced through the actions and behaviours of leaders at all levels of the organisation. By fostering a culture of collaboration, learning, and continuous improvement, we can create an environment conducive to the adoption of effective practices.

In conclusion, technological advancements are of little import in software development, unless accompanied by cultural changes. Alan Kay’s concept of obliquity reminds us that sometimes the most direct path is not the most effective. By focusing on building a culture that values collaboration, learning, and continuous improvement, we can deliver better outcomes for our businesses and customers.

Revolutionising Solution Delivery: The Power of Artefact Driven Delivery

Artefact Driven Delivery is a method of solution delivery, created at Familiar, that focuses on using artefacts as the main unit of progress, instead of tasks. This approach avoids the Cost of Delay, deferred feedback, and other risks associated with traditional approaches to solution delivery. Approaches which delay work on implementing a solution until all requirements, designs, etc. are fully defined. Instead, skeleton standard artefacts are available from the beginning of the solution development process, are based on standard templates. The artefacts are then gradually filled with solution-specific content as they are needed for implementation and delivery.

The standard artefacts used in this approach include the Control Document, Articles of Understanding, Glossary of Terms, Statement of Purpose, Case for Action, Vision, Folks That Matter and their Needs, Risk Parade, Top Risks, Functional Requirements, Non-functional Requirements, Critical Success Factors, Feature Schedule, Quality Plan, Test Plan, Change Control, Cycle Plans, and Cycle Reviews. These artefacts are continually shared with clients and serve as a running history of the endeavour.

The Artefact Driven Delivery approach follows the Antimatter Principle which is covered extensively on my blog. For the curious, the “Javelin” White Paper provides a more in-depth explanation of each of the artefacts.

In conclusion, Artefact Driven Delivery is a method of solution delivery that emphasises the use of artefacts as the main unit of progress. It avoids the risks associated with traditional approaches, by establishing standard artefacts from the beginning of the solution development process and gradually filling them with solution-specific content as needed.

This approach results in a running history of the solution development and better communication between clients and the development team.

Waiting In The Wings

What’s going to the next big thing in terms of approaches to software delivery? And when might we expect the transition to that next big thing to become apparent?

“The future’s already here – it’s just not evenly distributed.”

~ William Gibson

The Days of Agile Are Numbered

We can argue about how much life the Agile approach to software delivery has left in it. What’s beyond dispute is that there will be something after Agile. And I propose it will  look much different from Agile. I find it inconceivable that Agile is so perfect that there’s no room for improvement. Even though – ironically, give the exhortations to “inspect and adapt” – many in the Agile supply chain don’t want to talk about it AT ALL. Why rock the boat and derail the gravy train?

Customers and users, however, are waking up to the inadequacies of presently lauded approaches. And current upheavals in organisations, such as remote working and the scramble for talent, are accelerating these folks’ dissatisfaction.

Holding You Back

What’s prolonging the transition towards any new approach? Basically, it’s the prospect of the serious pain that comes with the adoption of effective new approaches. SAFe’s transient popularity illustrates how many organisations prefer an ineffective approach, with the illusion of change, rather than an effective approach that actually brings benefits. Any significant uplift in software delivery and product development performance implies a much different approach to running technology organisations, including, not least, different styles of management.

Your View?

What’s your view? What promising new approach(es) do you see waiting in the wings? And if there’s nothing with a recognisable name or label, what characteristics will a new approach have to have to boost it into consideration?

– Bob

Do you want conventional solutions to software delivery, or performant solutions? (You can’t have both).

Hardware design / development has had Muntzing since the 1940’s. How about importing the idea into software design / development?

Could this facilitate the spread of #NoSoftware?

Or are programmers too self-indulgent to cut out much of their crap?

 

Reasons To Be Cheerful, Part 3

Reasons to be cheerful, Pt. 3

Some of you dear readers may, entirely reasonably, assume that I mention my books in the hope of increasing sales. However, this just ain’t so.

I mention my books in a vainglorious attempt to effect some positive shift in the world of business. I’ve written many times about my motivation. Specifically, my delight in helping people have a more joyful time in the world of work (in particular, Collaborative Knowledge Work).

I truly believe that Organisational Psychotherapy is a path to saner, more joyful, more humane workplaces. And my book “Quintessence” illustrates and maps out what a saner, more joyful organisation looks like and works like, in detail.

Maybe you share my enthusiasm for change, and for seeing things improve. Maybe you’re content with – or at least resigned to – the status quo.

In any case, I’d hate for my enthusiasm to be a source of frustration or angst for you.

On the other hand, I’d be delighted if through reading one or more of my books – or even blog posts or white papers – you might find a different perspective on what ails you, and new, more effective ways to meet folks’ needs, including your own.

– Bob

cheerful_lyrics

Further Reading

Marshall, R.W. (2021). Quintessence: An Acme for Software Development Organisations. [online] leanpub.com. Falling Blossoms (LeanPub). Available at: https://leanpub.com/quintessence/ [Accessed 16 Jun 2022].
Marshall, R.W. (2021). Memeology: Surfacing And Reflecting On The Organisation’s Collective Assumptions And Beliefs. [online] leanpub.com. Falling Blossoms (LeanPub). Available at: https://leanpub.com/memeology/ [Accessed 16 Jun 2022].
Marshall, R.W. (2018). Hearts over Diamonds: Serving Business and Society Through Organisational Psychotherapy. [online] leanpub.comFalling Blossoms (LeanPub). Available at: https://leanpub.com/heartsoverdiamonds/ [Accessed 16 Jun 2022].
Marshall, R.W. (2021). Organisational Psychotherapy Bundle 1. [online] Leanpub. Available at: https://leanpub.com/b/organisationalpsychotherapybundle1 [Accessed 16 Jun. 2022].
http://www.youtube.com. (n.d.). Ian Dury and The Blockheads – Reasons To Be Cheerful, Pt. 3 (Official Lyrics Video). [online] Available at: https://www.youtube.com/watch?v=1injh4-n1jY&ab_channel=IanDury%26TheBlockheads [Accessed 16 Jun. 2022].

Building Things

We could describe my whole career as one of building things.

Early on, these things included software, hardware and tech products such as fax servers, compute clusters, compilers, interpreters, network systems, operating systems, development languages, applications, databases, and so on.

Later, things morphed to building teams, communities, software development and delivery groups, business units and tech companies.

Most recently, the things I build have morphed again, into techniques, approaches, tools and know-how applicable to building things.

Learnings

This post is mainly concerned with sharing some of the insights I’ve gleaned over the years. Insights into effective ways of building things:

Purpose

When embarking on building a new thing, I choose to dwell for a while on the purpose of the thing I’m building: Who’s it for? What will they use it for? How will they use it? What needs do they have that this thing willl address?

Needs

What does the Needsscape look like? How can we anticipate it changing over time? And how will we monitor and respond to those changes?

Intentionality

Doing things with a clear understnading of where those things fit in the scheme of things. Rather than just spinning the wheels for the sake of feeling busy.

Quality

Answer the question: “How will we ensure that what we’re building manifests the quality/qualities needed by all the Folks That Matter?

Risks

Manage all key risks facing us in bulding the thing (and in deploying, using it too). See Tom Gilb’s “All Holes In The Boat” principle (any one key risk can sink the whole effort).

Incrementality

Build things in small increments. Get regular feedback from all the Folks That Matter, early and often. Whilst continually remaining open to the system-wide impact of what’s being built.

Clarity of Communication

One can never have too much communication. One can never have too much clarity of communication. I prefer to use Quanitification as the means to improving clarity of communication.

Make Things Visible

Particularly with the kinds of things I’ve been building over the years, things nebuluous and more or less invisible most of the time, it helps to find ways to make e.g. progress visible and clearly understandable to all the Folks That Matter.

PDCA

Often called the Shewhart Cycle or Deming Cycle. PDCA (Plan-Do-Check-Act) offers a conceptual framework for building things:

  • Plan what we’re going to do in the next days or weeks.
  • Do stuff according to that plan.
  • Check how well we did stuff (identify shortcomings)
  • Act to address some shortcomings in our doing, so that the next cycle’s doing goes better.

Ownership

Deming banged on about the necessity for people to have pride in what they do. I find pride is enhanced through people feeling they own what they’re building.

Build Less

Build as little a possible. With the lowest tech possible. Commensurate with meeting folks’ needs. Remember YAGNI.

Summary

I don’t expect the above list to be of much use to anyone. Because, normative learning. C’est la vie.

– Bob

The Future Of Software Delivery

Are you curious about how software will get written and delivered in the future? When all the Agile malarkey has faded away?

About your career and what skills and abilities will be in demand in a few years’ time?

Take a look at my book “Quintessence“ for a detailed road map of what the future of software delivery looks like.

My book “Memeology” describes in detail how organisations can make this future theirs, starting today.

And “Hearts Over DIamonds” sets out the foundations for Organisational Psychotherapy – the core principles for our Quintessential future.

Or read the whole series, and get a deep understanding of the role of Organisational Psychotherapy in businesses of the future.

– Bob

Further Reading

Marshall, R.W. (2021). Quintessence: An Acme for Software Development Organisations. [online] leanpub.com. Falling Blossoms (LeanPub). Available at: https://leanpub.com/quintessence/ [Accessed 12 Jun 2022].
Marshall, R.W. (2021). Memeology: Surfacing And Reflecting On The Organisation’s Collective Assumptions And Beliefs. [online] leanpub.com. Falling Blossoms (LeanPub). Available at: https://leanpub.com/memeology/ [Accessed 12 Jun 2022].
Marshall, R.W. (2018). Hearts over Diamonds: Serving Business and Society Through Organisational Psychotherapy. [online] leanpub.comFalling Blossoms (LeanPub). Available at: https://leanpub.com/heartsoverdiamonds/ [Accessed 12 Jun 2022].

You Don’t Understand Software Delivery

And the more senior you are, the less you understand. Even if you were once a developer, given that most developers don’t understand software development / software delivery, a developer background is not going to help you much.

Who does understand software delivery? Folks who have studied it as a discipline. And that’s precious few indeed. Of all the “development” folks I’ve met over the years – and that’s thousands – wayyy less than one percent actually have an effective understanding of the field.

Yes, there’s thousands upon thousands of folks who understand coding (programming). But that’s not much help at all in forming a broader and effective understanding of the wider software delivery discipline.

The upshot? The software industry is stacked to the gills with folks who have no clue what they’re doing, except in the narrowest of specialism. And worse, no ability to recognise the one percent. Result? The blind leading the blind. And the hegemony of the one-eyed man.

– Bob