Accelerate

How do some organizations ship better software faster while others drown in delays, burnout, and bureaucracy? In Accelerate, authors Nicole Forsgren, Jez Humble, and Gene Kim reveal a powerful truth: excellence in software delivery isn't born of luck or genius; it comes from measurable, repeatable, research-backed practices. Their groundbreaking four-year study of over 23,000 professionals across 2,000 organizations proves that high performance in technology is achievable and predictably linked to specific behaviors, cultures, and management techniques.

At its heart, the book argues that software delivery performance drives organizational performance. In a world where every business—from a bank to a shoe store—is effectively a software company, your ability to deliver, test, and deploy software quickly and safely has a direct impact on profitability, productivity, and market share. Accelerate demolishes the myth that speed and stability trade off against each other. Instead, it shows that the world’s best organizations—like Amazon, Netflix, and even government innovators such as the U.S. Digital Service—achieve both simultaneously through smart architecture, empowered teams, and a generative culture.

From Maturity to Capability

One of the book’s most important contributions is to challenge the traditional “maturity model.” Maturity, the authors explain, implies that organizations evolve through static stages toward a final goal. But in software, where technology and customer needs continually shift, there is no “mature” endpoint. Instead, capability models—focusing on the specific skills and practices that drive ongoing improvement—are the true markers of success. Capability models emphasize continuous learning and adaptation, ensuring organizations keep improving rather than declaring victory.

The Data-Driven DevOps Revolution

Through rigorous statistical research methods often reserved for academia, the authors distilled 24 key capabilities that truly move the needle on performance. These include technical practices like continuous integration, test automation, and version control; architectural decisions such as loosely coupled systems; Lean management techniques like visualizing work and limiting work in progress; and cultural enablers like trust, learning, and transformational leadership. Each was tested against measurable outcomes such as faster lead times, fewer failures, and higher team satisfaction. In every case, the data show that these practices predict—not just correlate with—superior results.

(Historically, similar lessons arose from Lean manufacturing pioneers like Toyota, but Accelerate adapts them to the modern software landscape. Like W. Edwards Deming’s insistence on building quality into the process rather than inspecting it after the fact, Forsgren, Humble, and Kim argue for integrating testing, security, and feedback throughout the development lifecycle.)

Performance That Scales

The research revealed stark differences between high and low performers. The best teams deploy code 46 times more frequently, recover from failures 170 times faster, and experience far fewer defects. Crucially, they aren’t just “tech unicorns.” The findings hold true across industries—from finance and healthcare to government—and apply equally to greenfield startups and legacy giants. Size, tech stack, or age of system doesn’t determine success; practices do.

This evidence-based clarity allows you to move beyond faith and buzzwords. Rather than guessing which DevOps tools or management fads to adopt, Accelerate provides a clear, prioritized roadmap grounded in empirical results. It empowers leaders to make data-driven decisions about change, technology investment, and organizational design.

Why It Matters

When you adopt these practices, the payoffs cascade: not only do systems become faster and safer, but teams experience less burnout, higher satisfaction, and stronger identity with their organization’s mission. Improved delivery performance isn’t just an IT achievement—it becomes a competitive advantage. Companies that deliver software quickly and reliably outperform peers in stock growth, profitability, and innovation.

Ultimately, Accelerate is both a research study and a manifesto. It calls on today’s technology leaders to view software delivery capability as a strategic priority, not a cost center. It combines scientific rigor with real-world stories—from pioneering DevOps leaders like ING Bank’s transformation to the U.S. Government’s agile initiatives—to prove that high performance is not a myth. If your organization depends on software (and whose doesn’t?), the book argues, your future depends on learning to accelerate.

How do you know your software teams are improving? Many leaders fall back on outdated metrics like lines of code, velocity points, or utilization—all of which the authors show are fundamentally flawed. In Accelerate, Forsgren, Humble, and Kim redefine performance measurement around outcomes instead of outputs. Instead of counting how much code a developer produces, they suggest measuring how effectively teams deliver value to customers and recover from problems.

The Four Key Metrics

The authors identified four core measures of software delivery performance:

• Delivery lead time—the time it takes for code to go from commit to running in production.
• Deployment frequency—how often software is deployed or released to users.
• Mean time to restore (MTTR)—how quickly systems recover from incidents or outages.
• Change fail rate—the percentage of changes that cause service impairment or require remediation.

Together, these metrics capture both tempo (speed) and stability (quality)—the two essential dimensions of delivery performance. Unlike old productivity measures, these provoke collaboration across teams rather than competition between them. Developers, testers, and operations must work together to improve shared goals.

No Trade-Off Between Speed and Stability

Perhaps the book’s most surprising finding is that high-performing teams are faster and more stable at the same time. While many executives believe you must sacrifice stability to move fast, the data shows the opposite: teams that build quality into their processes—through automation, testing, and good culture—achieve both. This refutes the old “bimodal IT” myth where innovation teams moved quickly but clumsily while legacy departments were slow but stable.

(Martin Fowler, who wrote the book’s foreword, compared this shift to the mindset revolution Eric Ries described in The Lean Startup: continuous improvement through rapid experimentation beats long planning cycles every time.)

Linking IT to Business Results

In one of the most powerful correlations the authors uncovered, software delivery performance predicted organizational performance. Across industries, high-performing technology teams were twice as likely to exceed profitability, productivity, and market-share goals. Even in nonprofit or government sectors, better delivery predicted improved efficiency, quality of service, and mission outcomes. This means that software excellence isn’t just a tech concern—it’s a boardroom imperative.

From Vanity Metrics to Valid Measures

To validate their approach, the authors used cluster analysis, a rigorous statistical technique that groups organizations by performance patterns. Across four years of data, “high,” “medium,” and “low” performers showed consistent, statistically distinct behaviors on each metric. High performers didn’t just deploy faster—they spent less time on rework, had fewer failures, and recovered faster when something went wrong. Measuring these outcomes allows teams to make evidence-based decisions about improvements rather than relying on gut feel or peer anecdotes.

Armed with these four metrics, you can confidently benchmark your organization and track progress. More importantly, these measures shift the conversation from “how busy are we?” to “how effectively do we deliver value?” That’s a transformation as cultural as it is technical—and it’s where genuine acceleration begins.

Every DevOps veteran knows that culture matters, but Accelerate delivers the data to prove it. Drawing on sociologist Ron Westrum’s model of organizational culture, the authors show that the way information flows within your organization literally predicts your delivery and business performance. Culture isn’t fluff—it's infrastructure.

The Westrum Continuum

Westrum identified three main culture types: pathological (power-oriented), bureaucratic (rule-oriented), and generative (performance-oriented). Pathological cultures hoard information and shoot messengers. Bureaucratic ones follow the rules rather than the mission. Generative cultures, by contrast, focus on shared purpose, trust, and learning from failure. In technology, these distinctions aren’t philosophical—they determine whether your systems will thrive or collapse under pressure.

Forsgren and Kim discovered that generative, high-trust cultures strongly predicted higher software delivery performance, stronger job satisfaction, and better organizational outcomes. In contrast, rule- and power-oriented environments correlated with higher bottlenecks, fear, and burnout. This aligns with Google’s later research on team effectiveness, which also found psychological safety to be the single biggest factor in team performance.

You Can Act Your Way to a Better Culture

A key message is that you don’t have to wait for leadership epiphanies to change culture; you can start by changing behaviors. The authors found that implementing technical and Lean practices like continuous delivery, limiting work-in-progress, and feedback-driven management directly improves culture. In other words, adopting DevOps disciplines helps build trust and collaboration—confirming John Shook’s insight that behavior precedes belief: “You change how people behave, and then culture follows.”

(This echoes lessons from Lean pioneers at Toyota, where standardized work and visual management not only improved efficiency but also reinforced teamwork and accountability.)

Measuring the Intangible

Using advanced survey methods from organizational psychology, the authors translated Westrum’s qualitative concepts into measurable data. They developed a “Westrum continuum” scale that gauged collaboration, learning, trust, and openness across teams. The result: even culture can be quantified, tracked, and intentionally improved.

This finding rescues culture from the realm of vague aspirations and grounds it in practice. For your organization, it means that adopting evidence-based behaviors—building quality in, visualizing work, and facilitating honest learning from failures—will not only deliver faster code but also nurture a workplace people love to belong to. Culture and performance are not separate—they are the same phenomenon at different scales.

Continuous delivery (CD) is often misunderstood as mere automation. In Accelerate, it’s portrayed instead as a complete system of principles, culture, and technical practices that allow teams to deliver changes safely, quickly, and sustainably. Rather than chasing speed, CD builds stability, quality, and learning into the development process itself.

Five Core Principles

CD rests on five key ideas:

• Build quality in: detect and fix problems immediately, not at the end.
• Work in small batches: deliver incremental value and gather feedback fast.
• Automate repetitive work: free people to solve problems creatively.
• Continuously improve: make learning part of daily work, not a side project.
• Share responsibility: align development, testing, and operations around joint outcomes.

Teams that follow these principles can deploy at will, confident that each change is low-risk and reversible. The book cites companies like Microsoft’s Bing team and ING Bank, where implementing CD transformed release cycles from months to hours while boosting employee satisfaction.

Key Practices of CD

The research identifies specific practices associated with CD success:

• Comprehensive version control for all production artifacts.
• Reliable, developer-maintained test automation.
• Trunk-based development with short-lived branches.
• Test data management to enable consistent automated testing.
• Shift-left security—integrating infosec into the development process.

When these are combined with a loosely coupled architecture and team autonomy, CD becomes a feedback amplifier: faster deployments yield faster learning, which yields better products and happier teams.

Beyond Speed—Sustainability and Quality

Perhaps most encouraging, CD also improves quality of work life. Teams practicing CD experience lower deployment pain, less burnout, and stronger identification with their organization. When builds are automated, predictable, and safe, developers sleep at night—and customers get better software. The authors even measured time spent on unplanned rework, finding that high performers spent nearly half their time on new work compared to low performers stuck fighting fires.

In essence, continuous delivery operationalizes trust. It gives teams the confidence to move fast because they’ve built the safety nets—tests, monitoring, and automation—that make speed possible. It’s not about working harder; it’s about engineering your process so improvement never stops.

If continuous delivery is the engine, then architecture is the chassis that supports it. Chapter 5 of Accelerate shows that no matter how skilled your developers are, a rigid or overly coupled architecture will drag you down. The secret? Architect systems—and teams—so each can change and deploy independently.

Testability and Deployability

The authors discovered that high-performing teams share two architectural superpowers: testability and deployability. They can test their systems without spinning up massive integrated environments, and they can deploy one component without coordinating a dozen others. That independence accelerates feedback loops and minimizes cross-team friction.

The Inverse Conway Maneuver

Drawing on Melvin Conway’s famous adage—“organizations which design systems are constrained to produce designs which mirror their communication structures”—the book introduces the “inverse Conway maneuver.” Rather than letting org charts dictate coupling, intentionally shape teams to achieve desired architectural outcomes. Cross-functional, self-contained teams that own a service end-to-end produce modular, resilient systems almost by design.

(ThoughtWorks popularized this insight in its Technology Radar, and Forsgren’s data provides hard proof that it works.)

Scaling Performance

One striking result from the research: as high-performing organizations added developers, their deployment frequency per developer actually increased. For low performers, it declined. This inversion shows that modular architecture enables scaling without chaos. When teams are decoupled, adding people increases capacity rather than communication overhead.

Empowering Teams with Tool Choice

Architectural empowerment also means freedom to choose appropriate tools. While some enterprises enforce strict technology standards for cost savings, high performers balance standardization with autonomy. Teams that can choose their language, frameworks, or CI tools report higher satisfaction and faster delivery. Central teams, meanwhile, provide reusable, well-designed libraries and infrastructure components rather than mandates.

Ultimately, loosely coupled architecture isn’t just about services—it’s about how your organization learns. Design for independence at both system and human levels, and your teams will evolve, experiment, and deliver at a pace rigid hierarchies can’t match.

In traditional organizations, security sits at the end of the delivery pipeline, waiting to block releases. Accelerate challenges this defensive pattern with the idea of shifting left on security: integrating infosec into every stage of the development lifecycle. Done right, security enhances velocity instead of throttling it.

Shifting Left

Shifting left means performing security reviews early, embedding security professionals in teams, and testing for vulnerabilities continuously. Security isn’t a gate—it’s a guide. The authors found that teams which involved infosec during design and included automated security tests in their CI pipelines not only delivered more secure code but also achieved higher overall delivery performance.

High performers, in fact, spent 50% less time remediating security issues than low performers. The evidence is clear: preventative design beats retroactive audit.

The Rugged Movement

Forsgren and Humble highlight the growth of the Rugged DevOps movement, inspired by security experts like Josh Corman and James Wickett. Their “Rugged Manifesto” urges engineers to view resilience as everyone’s job. This aligns with DevSecOps and Lean principles: build safety into the system, don’t inspect it in later. In high-velocity organizations—from Capital One to the U.S. federal government’s cloud.gov platform—security automation and preapproved library packages have made compliance faster, cheaper, and safer.

Integrating security early teaches an important leadership lesson: speed and safety are not enemies. They grow from the same root—engineering discipline. When security becomes part of daily work, developers act like guardians, not gate crashers.

The final chapters of Accelerate reveal an often-overlooked force behind all successful transformations: transformational leadership. Technical excellence alone can’t drive organizational change. Leaders must inspire, coach, and cultivate trust to unleash their teams’ potential.

Five Dimensions of Transformational Leadership

Drawing from decades of management science, the authors identify five behaviors shared by effective technology leaders:

• Vision: setting a clear, inspiring direction that connects technology work to enterprise purpose.
• Inspirational communication: motivating teams through authentic storytelling and appreciation.
• Intellectual stimulation: challenging assumptions and encouraging problem-solving.
• Supportive leadership: showing empathy and understanding personal needs.
• Personal recognition: celebrating individual contributions and improvements.

Teams led by such leaders report higher delivery performance, better implementation of Lean and DevOps practices, and stronger engagement scores. Conversely, teams with passive or authoritarian managers stagnate—even when they have technically skilled engineers.

Amplifying Team Capability

Leaders don’t improve code directly—they improve the systems and culture that produce it. Effective managers, the authors argue, align strategic goals with day-to-day work, remove friction, and invest in capability-building. At organizations like ING Netherlands, leaders turned shared learning into habit through Obeya rooms and visual management, allowing distributed teams to stay aligned without micromanagement.

The story of IT manager Jannes Smit is illustrative: by empowering teams to prioritize quality over deadlines and shielding them from political backlash, he fostered an environment where trust, ownership, and innovation flourished. His approach turned massive, legacy IT departments into adaptive learning organizations.

A Call to Continuous Learning

Ultimately, transformational leadership isn’t about authority or charisma—it’s about modeling curiosity and discipline. The most successful leaders treat organizational improvement as ongoing practice, not a project. They learn publicly, coach relentlessly, and make it safe for others to experiment. Accelerate closes with this conviction: high performance arises when leadership, culture, and technology co-evolve. You don’t just improve systems; you build a community that learns faster than the competition.