Key Takeaways
Put users in the room before expensive assumptions harden.
Feedback beats theatrical reveals. In a familiar failure pattern, a team builds in isolation, then discovers at delivery that its software solves the wrong problem. One company spent $5 million redesigning its ordering system. The redesign broke the logical item-number patterns that staff had memorized and scattered related products across separate screens. Ordering slowed, users were angry, and the project exceeded its time and cost targets. A brief, early review with the people who actually place orders could have exposed the flaw before it became expensive to undo.
Start with the work. Ask users to show how they do their jobs, what they need the system to accomplish, and where the current process frustrates them. Sponsors should explain the business purpose and trade-offs, while developers decide how to build the solution.
What's important here is that user involvement is not simply a courtesy or a late-stage approval ritual. It is a way to uncover tacit knowledge: the habits and workarounds people may not think to mention in a formal requirements document. The ordering example shows how a design can be internally tidy yet operationally clumsy. Still, users are experts in their work, not necessarily in the best technical solution. Good collaboration combines their lived experience with the team's design judgment, rather than treating every request as a specification.
Treat requirements as hypotheses, then test them in short cycles.
Build to learn. Requirements are difficult to define completely because people may mean different things by the same words, and their needs can change as they see a working product. One web project specified pages with a fixed width and height of 800 by 600 pixels. The customer supplied far more content than could fit on that screen, then objected when users had to scroll vertically. The written requirement had not captured the real expectation.
Make uncertainty visible. Break the work into small increments, create a prototype, and ask users to respond. The book recommends short cycles, often one to three weeks, so misunderstandings surface while they are still manageable. Prioritize essential features against optional ones, and identify dependencies before cutting scope. A software project cannot be made perfectly predictable by writing more detailed requirements at the start.
Short cycles turn disagreement into evidence. A prototype gives users something concrete to react to, which is often more productive than debating abstract descriptions. This is also a form of risk management: the team spends a little effort early to reduce the chance of a large mismatch later. Iteration is not a substitute for thinking, however. Without clear priorities or a business purpose, rapid feedback can become rapid scope churn. The useful discipline is to learn quickly while keeping a stable sense of which problem the project is meant to solve.
Budget for code that can change, not code that merely ships.
The first version is not the whole cost. A developer who rushes a feature may appear faster than a colleague who improves its structure and writes tests. But when customers request changes, the rushed code can break unrelated behavior, producing a cycle of unpredictable fixes. Tests and refactoring take time up front, yet make later changes safer. Refactoring means improving a program's internal structure without changing what it does.
Track shortcuts as debt. Technical debt is the future cost created by temporary shortcuts, weak documentation, or design compromises. After each work cycle, identify specific repairs, estimate them, and schedule them alongside new features. The book's 60/60 Rule says maintenance averages 60% of software life-cycle cost, and enhancements account for about 60% of maintenance work. These are averages, not guarantees, but they show why maintainability matters.
The debt metaphor helps translate an engineering concern into a business decision: a shortcut may buy time now, but it can make later work more expensive. Its value depends on keeping the debt visible and specific. Otherwise, the label can become a vague argument for unlimited cleanup. The 60/60 figures are useful as a warning, not a universal forecast, since maintenance costs vary by system and context. The durable principle is to judge a delivery by its future changeability as well as its initial completion.
Make software absorb complexity instead of handing it to users.
Simplicity takes work. A microwave with a long menu of food categories can make reheating leftovers harder than pressing a basic button. Software can do the same thing when it exposes internal complexity instead of making a task easier. The project manager can act as a complexity sink: clarify contradictory requests for developers, and explain technical constraints to users in terms that help them choose.
Reuse before reinventing. Teams that build their own frameworks, testing tools, or database layers often inherit problems that established tools have already solved. Buying ready-made software can also save effort, but only after testing it against real needs. Before signing, document requirements, evaluate the vendor, and run test cases. A feature-rich product that does not fit the user's process may be worse than a simpler, reliable one.
This principle links user experience to project economics. Every extra choice or workaround imposed on a user becomes part of the product's operating cost, even if it never appears in the development budget. Reuse likewise frees attention for the problem that distinguishes the project. Yet simplicity should not be confused with removing useful capabilities or forcing every organization into one tool. The right test is whether complexity has been eliminated, automated, or merely hidden in a place where users and maintainers will pay for it later.
Build teams around learning, trust, and sustainable concentration.
People are not interchangeable capacity. One contributor argues for hiring for qualities such as curiosity, cooperation, and willingness to learn, rather than matching a résumé to a narrow list of current tools. Skills can be taught more readily than the ability to work well with others. A story about a developer named Tim shows how management style can distort performance: he seemed idle when a controlling manager assigned work without providing the next priority. On a team with shared priorities, he became a top contributor.
Protect the conditions for good work. Programming requires sustained attention. The book recommends setting aside interruption-free periods, limiting how often developers switch projects, and avoiding a culture of routine overtime. It also urges managers to build morale by listening, recognizing useful contributions, and allowing the team meaningful ownership.
The chapter collection treats productivity as a property of the work environment, not just an individual's effort. That is a useful corrective to the idea that performance problems always call for pressure or replacement. Clear priorities, room to focus, and trust can reveal capability that micromanagement suppresses. The approach still requires accountability: autonomy works best when outcomes, decision rights, and support are explicit. Sustainable pace is not an excuse to ignore a deadline; it is a way to avoid making exhaustion the project's default operating system.
Use communication to unblock work, not to manufacture meeting activity.
Make information easy to find. Meetings should have a purpose, a focused agenda, and only the people needed to act. The book recommends short stand-ups for sharing completed work, current plans, and impediments, with detailed problem-solving moved to smaller groups. Shared tools such as a wiki or task board can keep decisions, procedures, risks, and project status accessible without repeated email chains.
Connect people directly. A project manager who relays every message risks becoming a bottleneck and distorting technical or business information. Bring the right people together when a decision needs their knowledge. For distributed teams, make time-zone overlap, contact details, shared calendars, and project artifacts visible. Communication should reduce uncertainty and help someone take the next step, not just prove that a meeting happened.
The useful distinction is not between meetings and tools, but between communication that changes what people can do and communication that only records activity. A shared knowledge base supports asynchronous work, while a direct conversation can resolve ambiguity that a document cannot. Each mode has a cost: too little interaction fragments understanding, while too much synchronous communication interrupts concentrated work. Strong project communication therefore depends on matching the channel to the decision, preserving important agreements, and resisting the temptation to make the project manager the only route through which information can travel.
Measure user-visible value, not reassuring percentages or busy hours.
Progress needs a customer test. In one project, team leads reported that their work was nearly complete, but users found the integrated system unusable and full of critical defects. A component being finished is not the same as the product working for its intended user. Define what finished means across coding, testing, integration, documentation, and user acceptance, then check progress against that definition.
Choose measures carefully. Counting hours can reward overtime; counting features can reward low-value output; counting bugs can encourage teams to optimize the wrong thing. Estimates should be revisited as knowledge improves, and developers should raise risks early rather than hide a likely miss. Use a small number of metrics tied to the current business goal, and revise them when the problem changes.
Metrics are behavioral signals. Once a number becomes a target, people may optimize the number rather than the outcome it was meant to represent. User evaluation and integrated tests make status more credible because they examine whether the system functions as a whole. They do not eliminate judgment: some benefits, such as reduced risk or improved maintainability, may not appear as immediate feature counts. A sound measurement system combines observable delivery with context, and treats estimates as information for decisions rather than promises to punish.
Plan deliberately, then revise against reality without worshipping the plan.
Planning creates shared understanding. A work breakdown structure, or WBS, divides the project's deliverables into manageable components and gives the team a foundation for scheduling, budgeting, and risk review. The triple constraint describes the trade-offs among scope, time, and cost, with changes to one often affecting the others and the resulting quality. Sponsors should clarify what matters most and provide the resources required to achieve it.
Keep plans adaptable. Add schedule buffers where risk is high, and update estimates as the team learns. A plan is a tool for discussion and coordination, not proof that reality must obey the original forecast. Assign one accountable owner to each deliverable, establish change-control expectations with clients and vendors, and choose only the processes that fit the project. Standardization helps when it reduces confusion; excess paperwork can consume the work it is meant to support.
Planning earns its value by preparing people to make better decisions when circumstances shift. A shared map lets a team respond without waiting for the project manager to prescribe every move. The distinction between disciplined planning and rigid compliance is essential: abandoning plans entirely leaves stakeholders without a common basis for trade-offs, while treating every baseline as sacred encourages concealment and delay. Buffers are most credible when linked to identifiable uncertainty and not added repeatedly at both task and phase levels. Good governance clarifies who decides, what gets escalated, and why.
Map integrations and language work before small changes multiply.
Dependencies hide outside the feature. During a system upgrade, a vendor deleted database views that appeared to block installation. Those views also supplied customer data to another application, so the upgrade quietly broke an integration. A simple diagram of how data moves between systems could have revealed the risk. Identify interfaces, owners, and test points before changing a connected system, then integrate and test components in stages rather than waiting for one final merge.
Plan for distance and language. A small change to English text can trigger translation and retesting across every localized version, so the schedule needs a cutoff for ordinary English changes and a buffer for localization work. Distributed teams also need practical coordination: shared project information, clear contacts, workable meeting times, and realistic assumptions about connectivity and local calendars.
This is a reminder that the project's real boundary is wider than its codebase. Data flows, vendors, translations, user routines, and time zones all create dependencies that can turn a harmless local edit into a system-wide delay. Mapping these relationships is valuable because it exposes where coordination and testing must occur. Diagrams can become stale, however, so they need named owners and updates as systems change. The goal is not exhaustive documentation of every possible connection, but enough shared visibility to prevent a change in one area from surprising people elsewhere.
Analysis
This collection is less a single method than a field guide to the recurring gap between a project's paperwork and its lived reality. Its contributors repeatedly redirect attention from plans, status reports, and technical output toward the conditions that make useful software possible: users who can explain their work, sponsors who make trade-offs, developers who can concentrate, and teams that can revise assumptions without treating change as failure. The anecdotes make that argument memorable. A redesigned ordering system defeats users' learned routines; a developer appears unproductive under one manager and thrives under another; a supposedly almost-finished system collapses when a real user tries it.
The book's strongest synthesis is that project management is not control of all variables. It is the design of feedback, responsibility, and decision paths so problems become visible while there is still room to respond. That logic joins agile iteration with traditional tools such as scope statements, work breakdown structures, contracts, and governance. The apparent tension is productive: lightweight processes cannot mean absent accountability, and formal controls cannot mean pretending requirements are fixed. The useful standard is whether a practice helps people make informed decisions and deliver something users value.
The anthology also exposes a less comfortable organizational truth. Teams cannot compensate indefinitely for weak sponsorship, conflicting incentives, unavailable experts, or leaders who punish bad news. A project manager can build a healthier local environment, but some delivery risks are produced above the project level. The book is most persuasive when it treats quality and morale as organizational responsibilities rather than heroic individual traits.
Its 2009 examples and tools reflect their era, but the underlying questions remain practical: Can users test what is being built? Can the team explain what done means? Can an integration change be traced? Can a metric be gamed? The collection offers no universal recipe. Its value lies in teaching project managers to recognize these questions early, then choose the smallest process that makes the answer visible.
Review Summary
97 things every project manager should know receives mixed reviews, with an average rating of 3.20 out of 5. Some readers find it a useful collection of observations and best practices, while others consider it mediocre or generic. The book's strength lies in its diverse perspectives from multiple authors, offering insights into common project management challenges. However, many reviewers note that the advice can be superficial and lacks depth. Some appreciate the practical tips and real-world experiences shared, while others feel the content is too focused on software project management and may not be universally applicable.
Glossary
technical debt
Cost of deferred code repairTechnical debt is the future cost created when a team takes shortcuts, uses hacks, omits documentation, or departs from its intended design to meet an immediate deadline. Like financial borrowing, it can be a reasonable temporary choice, but unresolved debt makes future maintenance and change harder. The book recommends identifying specific repairs and scheduling them alongside new functionality.
60/60 Rule
Maintenance cost patternThe 60/60 Rule is the book's shorthand for two reported averages: maintenance accounts for about 60% of a software system's life-cycle cost, and user-requested enhancements account for about 60% of maintenance effort. The chapter notes that maintenance costs vary by system, and argues that software should be designed to accommodate change and remain understandable.
work breakdown structure
Hierarchical map of project workA work breakdown structure, or WBS, organizes the full project scope into a hierarchy of deliverables and smaller work packages. It gives stakeholders and the team a shared picture of what the project must produce, helps expose missing or duplicated work, and supports later planning for schedule, cost, and risk. The book recommends involving the people who will perform the work.
triple constraint
Scope, time, and cost trade-offsThe triple constraint is a project-management model describing the relationship among scope, time, and cost. Changing one commonly affects the others and can influence quality. In software projects, the book emphasizes discussing these trade-offs with sponsors and making priorities explicit, rather than assuming that every requested feature can be delivered on the original schedule and budget.
velocity
Rate of completed team workVelocity is an agile measure of how much work a team or individual completes during a period. It can help a team plan a coming iteration using its own recent experience. The book cautions against treating velocity as a universal measure of value: finishing more work quickly does not establish that the work solves the most important business problem.
CRAM model
Sequence for diagnosing performanceThe CRAM model stands for Constraints, Resources, Aptitude, and Motivation. It offers a sequence for investigating a person's performance difficulties. First consider personal or situational constraints, then whether necessary resources are available, then whether the role fits the person's aptitude. Motivation is considered only after these factors have been examined.
Fallacy of Perfect Knowledge
Belief in complete fixed requirementsThe Fallacy of Perfect Knowledge is the mistaken belief that a software project can capture complete, consistent requirements at one point in time. The book argues that requirements can be misunderstood, conflict, or change during development and maintenance. It recommends accepting uncertainty and using iteration and refactoring to adapt the product and its supporting understanding.
Download PDF
Download EPUB
.epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.