Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Leading the Transformation

Leading the Transformation

Applying Agile and DevOps Principles at Scale
Help a sprawling software organization ship reliably, without imposing one workflow on every team.
by Gary Gruver 2015 113 pages
3.80
418 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Improve how teams integrate before prescribing how each team works.

Fix the shared flow. In large organizations, teams can do good work locally and still struggle to deliver a usable product because their code must be combined, tested, and released with many other teams’ work. Gruver and Mouser argue that this coordination problem often matters more than whether each team follows a particular Agile routine. At HP’s LaserJet firmware group, development costs fell from about $100 million to $55 million, supported products increased by 140%, and capacity for innovation rose from 5% to 40%. The transformation focused on integrating changes early and frequently, while leaving teams room to choose how they worked.

Analysis

The argument shifts attention from team-level activity to the connections between teams, where delays and incompatibilities accumulate. That is a useful systems view: optimizing individual units does not guarantee an effective whole. The HP results make the possibility tangible, though they are a case study, not proof that the same interventions produce the same gains everywhere. Leaders should ask where work waits, gets recombined, or fails late, rather than treating a favored team method as the transformation itself.

Tie transformation spending to a business bottleneck, not Agile adoption.

Begin with the business. HP did not launch its firmware effort to earn an Agile label. The group had long constrained the LaserJet business, and hiring more developers had not solved the problem. Its objective became freeing capacity for innovation and ensuring firmware no longer blocked new products. That objective helped leaders select improvements and secure cooperation across business boundaries, including a move to a common hardware platform. The authors recommend identifying either the main cost and cycle-time drivers or common enterprise problems, such as difficult releases and wasteful planning. A method is worth adopting when it advances a defined business outcome, not simply because it is fashionable.

Analysis

A business objective works as a filter against transformation theater: it makes it easier to distinguish a useful practice from a popular one. It also gives different functions a reason to cooperate, since a delivery bottleneck rarely belongs to only one team. The caution is that productivity measures can become blunt targets. If leaders reward cost reduction alone, they may undermine quality or learning. A balanced objective should connect efficiency to the customer or business result the freed capacity is meant to serve.

Run enterprise improvement in short cycles, guided by evidence and employee learning.

Learn at the scale of work. Enterprise-level continuous improvement means executives and teams set a small number of shared objectives for an iteration, examine progress, and adjust priorities using what they learn. At HP, monthly objectives commonly included four to seven priorities, such as preparing a product release or improving test stability. Leaders reviewed measures, then spoke directly with people doing the work to understand obstacles the numbers could not explain. The next iteration’s objectives were drafted by leaders and revised with managers and project teams. This created a rhythm for changing direction without pretending to know, years in advance, every step of a multiyear transformation.

Analysis

This process combines two kinds of information: measures reveal where progress stalls, while conversations help explain why. Neither is sufficient alone. A dashboard without inquiry can turn into surveillance; informal impressions without shared measures can make priorities arbitrary. The authors’ emphasis on executives listening in the work environment gives the process a practical feedback loop. Its value depends on trust: employees need to believe that exposing a problem brings help and correction, not punishment for making the problem visible.

Preserve software’s flexibility by delaying detailed commitments until uncertainty shrinks.

Plan in horizons. Software is easier to alter than many physical assets, but long-range estimates remain uncertain, and the authors cite an industry estimate that more than half of software is unused or misses its intended business purpose. They recommend separating decisions by time horizon: make only essential long-term commitments, estimate nearer-term initiatives at a higher level, and keep a prioritized backlog for short-term work. At HP, detailed planning consumed about 20% of capacity; after the process changed, it took less than 5%. Requirements were elaborated closer to development, reducing effort spent refining work that might never be selected.

Analysis

This is an argument for treating plans as decisions with different shelf lives, rather than as one comprehensive promise. It preserves room to respond to new information without abandoning the commitments a business genuinely needs. The approach is not an excuse for vagueness: manufacturing, regulation, or external launch dates can impose real lead times. The useful question is which decisions must be fixed early and which details can remain provisional. Separating those categories can reduce both false certainty and costly replanning.

Make one stable shared code line the organization’s daily delivery priority.

Integrate continuously. Trunk development means teams work against one main code line and integrate changes frequently, rather than maintaining many long-lived branches. A stable trunk lets teams discover conflicts earlier and gives developers feedback in a production-like environment. At HP, contributors were expected to wait for automated checks after a commit and not add code to a failing build. The team later used gated commits, which keep changes that fail checks out of the shared code line until they are fixed. Techniques such as feature flags and versioned services help teams introduce unfinished or changing components without breaking working code.

Analysis

A shared trunk is not merely a source-control preference. It makes integration an ongoing responsibility instead of a risky event saved for the end. That can expose coordination costs earlier, when fewer changes are entangled. The authors rightly treat management behavior as part of the engineering design: tools can enforce rules, but leaders still need to make stability a common priority. The approach also depends on credible automated checks. A gate that frequently rejects sound changes, or misses serious failures, can erode confidence quickly.

Build automated tests that pinpoint the failing component, not just detect failure.

Make feedback actionable. Large organizations need extensive automated testing, but a high test count is not enough. Tests should be maintainable as software changes and should help identify which component caused a failure. A long end-to-end test may fail because of a broken search feature even when it was written to check a new payment option. Component-based tests isolate the behavior under examination, making failures easier to assign and resolve. The authors caution against simply recording manual test steps for playback, because small interface changes can make many tests brittle. They recommend close collaboration between development architects and testers when designing the test framework.

Analysis

A test suite is a communication system as much as a quality safeguard. Its signal is useful only when people can interpret a failure and trust that it points toward relevant code. This explains why adding more tests can sometimes increase maintenance work without improving diagnosis. The book’s emphasis on architecture and test ownership addresses that risk. There is a practical tradeoff, however: isolation can hide interactions that appear only when the full system is assembled. Component tests need broader integration checks alongside them, not instead of them.

Use a deployment pipeline to make every build, test, and release repeatable.

Automate the route forward. Continuous Delivery is an approach that automates and controls the steps for building, testing, configuring, and deploying software. A deployment pipeline defines how code progresses through increasingly representative stages, from component checks toward production readiness. Supporting practices include scripted environments and deployments, automated tests, revision-controlled changes, and tools that coordinate the sequence. The purpose is not automation for its own sake: repeatable steps reduce manual variation and make failures easier to locate. For a large, tightly coupled system, the pipeline may need staged testing and careful promotion of components before testing the full enterprise system.

Analysis

The pipeline turns delivery from a sequence of handoffs into an inspectable process. That matters because repeatability makes the system easier to learn from: when the same steps run consistently, a change in outcome is more informative. The design must still reflect the software architecture. A complicated pipeline can become its own fragile product if scripts are duplicated or poorly maintained. Leaders should therefore treat automation as infrastructure that needs clear ownership, just as application code does.

Raise trunk stability gradually by promoting tests that catch real failures early.

Improve the release baseline. Build acceptance tests define the minimum checks that code must pass before it advances through the system. As broader regression tests reveal failures, teams can add the most useful tests to this smaller, faster gate. The authors describe tracking test pass rates, open defects, feature completion, and green builds together to see what still stands between development and release. At HP, automated testing ran across simulators, emulators, and products, with different stages balancing speed, realism, and cost. The goal was not immediate perfection, but steadily reducing late release work by making the shared code more reliable.

Analysis

This is a feedback loop for improving the feedback loop itself. When a broader test catches a defect that an earlier gate missed, the organization can strengthen the gate and reduce the chance of repeating the same escape. The staged approach also recognizes that realistic testing costs more, especially for embedded systems. A caution: pass rates can become misleading targets if teams optimize the metric rather than test quality. Leaders should pair numerical trends with investigation of what failures mean and whether the tests still represent customer risk.

Start with one achievable iteration, then let visible obstacles set the next priority.

Begin before the plan is perfect. The authors advise leaders not to wait for a complete transformation blueprint. Start with clear business objectives, bring Development, QA, Operations, and business partners into the work, and agree on a small set of important, measurable goals. One possible first move is to establish a continuous integration process with automated checks, then learn whether the tests and build process are stable enough to support it. Review what was completed and what blocked progress, and use those lessons to set the next iteration. The transformation is a sequence of discoveries, not a single reorganization or a one-time rollout of team practices.

Analysis

The first iteration is valuable partly because it tests the organization’s ability to learn together. A modest, visible improvement can reveal whether leaders have aligned priorities, whether teams trust the feedback, and whether the technical foundations are adequate. That is more informative than an ambitious plan whose assumptions remain untested. Still, small steps should not become an excuse for endless pilots. Leaders need a clear mechanism for turning local learning into enterprise-wide changes when shared systems or policies are the source of the obstacle.

Analysis

The book’s central contribution is to redefine Agile transformation as an enterprise operating problem. Its focus is not primarily on ceremonies or team vocabulary, but on how planning, integration, testing, and release combine to determine whether many teams can deliver customer value together. This emphasis explains the recurring leadership role: executives control cross-functional priorities, change capacity, and the conditions under which engineering feedback is acted upon.

The strongest argument is the connection between technical practices and organizational behavior. A stable trunk requires more than source-control tools. It requires agreement that shared code quality outranks isolated progress. Automated testing only improves delivery when teams trust its results and can locate the source of failure. Planning flexibility only matters when the business can revise priorities. The authors therefore avoid presenting technology as a shortcut around management.

The HP LaserJet case gives the argument credibility and concrete scale, especially the reported decline in development costs and rise in innovation capacity. It remains a single organizational case, shaped by particular architecture, leadership, and product constraints. The book is most persuasive as a set of design questions and intervention principles, not as a guaranteed recipe. Organizations should test whether their bottlenecks truly lie in integration, release, or planning before copying a specific implementation.

A useful tension runs through the approach: enterprise coordination needs shared objectives and standards, while teams need discretion to adapt their work. Too much central control can slow local problem solving; too little alignment can preserve fragmented delivery. The authors’ proposed balance is to centralize outcomes and shared delivery conditions while leaving many day-to-day methods to teams. In practice, that balance must be revisited as architecture and risk change. The lasting lesson is to build an organization that can detect its own constraints, make them visible, and improve the delivery system without mistaking a method for the goal.

Summary in 30 Seconds
Enterprise software delivery often fails at the points where teams integrate, test, and release their work. Tie improvement to a business constraint, then set short, shared goals and adjust them using metrics and employee feedback. Frequent integration, targeted automated tests, and repeatable deployment steps make failures easier to locate. At HP, development costs fell from about $100 million to $55 million, supported products rose 140%, and innovation capacity grew from 5% to 40%. Planning effort dropped from 20% to under 5%.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.80 out of 5
Average of 418 ratings from Goodreads and Amazon.

Leading the Transformation is praised as a practical guide for executives implementing Agile and DevOps in large organizations. Readers appreciate its focus on real-world experience, emphasis on setting clear business objectives, and advice on incremental implementation. The book is commended for its concise yet informative content, particularly for its insights on continuous improvement and cultural change. Some criticize its high-level approach and lack of technical details. Overall, reviewers find it a valuable resource for leaders driving organizational transformation, though some note it may be too basic for those already familiar with Agile and DevOps concepts.

Your rating:
4.38
88 ratings
Want to read the full book?

Glossary

Enterprise-level continuous improvement

Shared iterative improvement

A recurring process in which executives and teams set a limited number of organization-wide objectives, track progress, discuss obstacles, and revise priorities for the next iteration. It combines business outcomes with process improvements and uses both measures and direct conversations to learn where the system needs attention.

Trunk development

Frequent shared integration

A development approach in which teams integrate changes into one main code line frequently instead of maintaining long-lived branches. The trunk is kept stable through automated checks and prompt repair of failures. Techniques such as feature flags and versioned services allow work to progress without exposing incomplete changes or breaking existing behavior.

Continuous Delivery

Automated release readiness

An approach to software development that automates and controls building, testing, configuration, and deployment so software can be released reliably and frequently. It commonly uses revision-controlled scripts, automated tests, and a deployment pipeline that moves code through progressively broader stages of validation.

Build acceptance tests

Minimum stability checks

A selected set of automated tests that defines the minimum acceptable stability for a build to proceed. If these tests fail, the code should not advance. The set can be strengthened using failures found by broader testing, helping catch recurring problems earlier and reduce the number of changes implicated in a failure.

Service virtualization

Simulated system dependencies

A testing technique that substitutes a simulated service for a real system component. Teams can develop and test against the simulated interface while other components are unavailable or changing. It helps isolate work and run tests more frequently, but the simulation may not perfectly match the real component, so teams still need end-to-end testing.

Gated commits

Reject failing changes

A source-control process that checks code changes before allowing them into the shared code line. Changes that fail specified automated tests are held back so the trunk remains stable, while the contributor investigates and fixes the problem. This limits the disruption of a failed build to the changes most likely responsible.

About the Author

Gary Gruver is an experienced technology executive and author known for his expertise in software development and DevOps. He has held leadership positions in major companies, including HP, where he led a significant transformation in the printer firmware division. Gruver's work focuses on applying Agile and DevOps principles to large-scale enterprise environments. He is recognized for his practical, business-oriented approach to implementing these methodologies. In addition to "Leading the Transformation," Gruver has authored other books on similar topics, sharing his insights and experiences with a wider audience. His writing style is noted for its clarity and focus on real-world applications, making complex concepts accessible to executive readers.

Download PDF

To save this Leading the Transformation summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.31 MB     Pages: 15

Download EPUB

To read this Leading the Transformation summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.42 MB     Pages: 16
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 25,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...