liveBook · Manning

Technical debt

Also called tech debt

Technical debt is the future cost, effort, or risk created by technical choices or deferred work that make a system harder to change, maintain, or operate.

How 16 Manning books explain it

Software Architecture Decision-Making

Technical debt is the future cost or limitation created by expedient technical choices or by allowing design constraints to accumulate.

How it is used
Frames expedient architectural choices as explicit obligations to weigh against delivery constraints and future consequences.
How deep it goes
Defines debt, supplies an assessment rubric, and explains ongoing review without prescribing repayment techniques.
Examples
Uses manual testing for a one-off change and a synchronous API instead of event-driven architecture under deadline pressure.
What you can do after
Evaluate/understand whether a shortcut is justified, reversible, owned, and proportionate to its future risk.

Read how Software Architecture Decision-Making explains technical debt →

Vibe Engineering

The accumulated cost and risk created when expedient software decisions or deferred maintenance make future development and operation more difficult.

How it is used
Uses technical debt to expose maintenance and operational costs hidden by rapid AI generation or postponed upgrades.
How deep it goes
Examines technical debt through implementation comparisons and production risks, without prescribing a numerical debt calculation.
Examples
Compares custom and library-based tracing, examines unverified parser snapshots, and describes vulnerable dependencies left pinned after failed upgrades.
What you can do after
Evaluate technical debt by examining generated code's maintenance surface, validating test baselines, and recognizing risks in deferred upgrades.

Read how Vibe Engineering explains technical debt →

Lead Developer Career Guide

The future cost of maintaining or changing software resulting from expedient choices or unresolved technical issues.

How it is used
Helps lead developers balance timely delivery with code quality and organize maintenance work alongside features and bugs.
How deep it goes
Defines the cost and its tradeoff, then gives preventative and sprint-planning tactics; it does not specify a debt-measurement formula.
Examples
Uses a loan analogy and a homegrown client-side data-management component that substantially slowed feature development.
What you can do after
Practice/perform debt management by documenting decisions, prioritizing estimated fixes, and negotiating sprint capacity with the product team.

Read how Lead Developer Career Guide explains technical debt →

Architecture Modernization: Socio-technical alignment of software, strategy, and structure

Technical debt is the future cost and constraint created by choosing expedient implementation or maintenance decisions over more durable solutions.

How it is used
Frames architectural and organizational constraints in business terms so stakeholders can judge modernization investment.
How deep it goes
Explains a reinforcing cycle of declining system health and rising modernization cost, but stops short of implementation-level remediation.
Examples
Uses a financial-services modernization effort, legacy integrations, bolt-on tools, and research estimating substantial developer time lost to debt.
What you can do after
Evaluate modernization proposals, expose misleading quick fixes, and communicate their business benefits and required investment.

Read how Architecture Modernization: Socio-technical alignment of software, strategy, and structure explains technical debt →

Think Like a Software Engineering Manager

Technical debt is the accumulated future cost of expedient technical decisions that make software harder to change or maintain.

How it is used
Uses technical debt to guide operational-excellence work, prioritization, service-health improvement, and communication with nontechnical partners.
How deep it goes
Defines causes, trade-offs, metrics, stakeholder communication, and reduction questions, but stops short of implementation detail.
Examples
Uses rising on-call workload and manual graph-database onboarding to show how debt affects teams, customers, costs, and reliability.
What you can do after
Apply it via design questions, quality measures, prioritized debt work, and concrete cost-and-impact discussions.

Read how Think Like a Software Engineering Manager explains technical debt →

Grokking Software Architecture

Technical debt is the future cost of short-term software design or implementation compromises made in favor of speed over quality and maintainability.

How it is used
Frames shortcuts as a tradeoff between immediate delivery and future software quality and maintainability.
How deep it goes
Defines future costs, explains repayment, and illustrates how an outdated configuration can cause a production failure.
Examples
Uses spaghetti code, a rushed delivery choice, and thermostat switches left unchanged after a specification update.
What you can do after
Evaluate shortcuts by weighing business needs, deadlines, maintainability, and measurable results.

Read how Grokking Software Architecture explains technical debt →

Delivering Machine Learning Projects: From design to deployment

Technical debt is the future cost created by expedient technical decisions that increase maintenance, correction, or evolution effort.

How it is used
Frames maintenance and production support as deliberate work to reduce accumulated correction, troubleshooting, and evolution costs.
How deep it goes
Defines the performance gap and identifies logging, monitoring, algorithm obsolescence, governance, and support as concrete debt-management concerns.
Examples
Uses missing logs, absent alerts, outdated models, failed data flows, and unclear support responsibility as concrete debt examples.
What you can do after
Diagnose technical debt by checking instrumentation, comparing model performance, clarifying ownership, and planning remediation and failure response.

Read how Delivering Machine Learning Projects: From design to deployment explains technical debt →

Graph Neural Networks in Action

Technical debt is the future cost of design or implementation decisions that require later rework, workarounds, or replacement.

How it is used
Prevents avoidable rework while graph datasets, schemas, models, and data pipelines evolve.
How deep it goes
Defines causes and gives iterative testing and refactoring procedures, but stops short of quantifying debt or detailing migration strategies.
Examples
Uses candidate-referral data, schema constraints, graph queries, attribute checks, edge-label checks, relationship counts, and unique identifiers.
What you can do after
Diagnose technical debt with graph integrity tests and refactor schemas or pipelines through measured iterations.

Read how Graph Neural Networks in Action explains technical debt →

Architecting Accessibility

Technical debt is the accumulated future cost created by choosing incomplete, inferior, or deferred technical solutions.

How it is used
Frames accessibility debt as a reason to include accessibility in product decisions from the requirements stage onward.
How deep it goes
Traces costs from inaccessible patterns in code, templates, and frameworks to embedded workflows and more expensive remediation.
Examples
Points to inaccessible patterns in code, templates, frameworks, habits, procurement practices, and development workflows.
What you can do after
Evaluate how delaying accessibility work increases remediation effort and cost, then raise accessibility during requirements and design.

Read how Architecting Accessibility explains technical debt →

"Looks Good to Me"

The future maintenance and remediation cost created by accepting an expedient or suboptimal software decision.

How it is used
Frames code-review decisions about whether rework is warranted or expedient code should be accepted with future cost.
How deep it goes
Identifies difficult review scenarios and prevention practices, but stops short of defining remediation plans or measuring debt.
Examples
Uses oversized pull requests, architectural problems, unagreed tools, incomplete requirements, misunderstood requirements, and subtle bugs.
What you can do after
Diagnose/debug with it by spotting tough review issues and choosing between rework, delay, and knowingly accepting debt.

Read how "Looks Good to Me" explains technical debt →

Think Like a CTO

Technical debt is the accumulated cost of choosing short-term technical solutions that make future software maintenance or change more difficult.

How it is used
Guides enterprise teams in recognizing, measuring, prioritizing, and repaying the maintenance cost of fast technical decisions.
How deep it goes
Explains causes, repayment allocation, measurement, backlog capture, and sprint practices, but stops short of implementation-level remediation.
Examples
Uses skipped vehicle maintenance, hardcoded values, client conditionals, and separate client repositories as concrete debt scenarios.
What you can do after
Operate a debt-management practice using code-quality tools, backlog entries, review checkpoints, repayment capacity, and extensible client-request designs.

Read how Think Like a CTO explains technical debt →

Build High Value Software Systems

Technical debt is the future cost created by implementation choices that make a system harder, riskier, or more expensive to change or operate.

How it is used
Frames implementation tradeoffs as future change and operational costs, then helps prioritize improvement.
How deep it goes
Defines debt as a tradeoff and works through a frequency-times-friction estimate, measurement, and a focused improvement exercise.
Examples
Uses a validation module with eleven hours of reported friction and a legacy-module exercise involving observation and characterization tests.
What you can do after
Evaluate debt using change frequency and friction, then target one small improvement in a high-cost module.

Read how Build High Value Software Systems explains technical debt →

Collaborative Software Design: How to facilitate domain modeling decisions

The future cost of deliberately choosing a less-than-ideal software design or implementation in order to deliver value sooner.

How it is used
Frames deliberate design compromises as obligations that teams should surface and manage during collaborative architectural decision-making.
How deep it goes
Defines deliberate debt, distinguishes it from implicit cruft, and outlines delivery and social consequences without detailing repayment procedures.
Examples
Uses inability to add functionality, slower production delivery, hacks, bugs, frustration, and communication breakdown as consequences.
What you can do after
Evaluate deliberate design trade-offs and make their risks and consequences explicit through collaborative modeling.

Read how Collaborative Software Design: How to facilitate domain modeling decisions explains technical debt →

The Art of Code

Technical debt is the future cost of maintenance and change created by expedient technical choices or unresolved implementation deficiencies.

How it is used
Frames shortcuts and design decay as costs that shape maintainability, change, debugging, and engineering judgment.
How deep it goes
Explains causes, compounding consequences, and architectural responses, but does not provide a debt-measurement method or repayment workflow.
Examples
Uses AI-generated patch loops, outdated protocols, obsolete libraries, spaghetti code, layered architecture, modules, and hexagonal architecture.
What you can do after
Evaluate expedient technical choices and recognize when clearer boundaries are needed to keep software changeable and understandable.

Read how The Art of Code explains technical debt →

PostgreSQL Mistakes and How to Avoid Them

Technical debt is the accumulated cost of delaying or choosing expedient implementations that make future changes or maintenance more difficult.

How it is used
Guides PostgreSQL teams toward early planning and intervention before performance, reliability, or scalability problems escalate.
How deep it goes
Explains preventive practices and inherited-database triage, but does not provide implementation-specific SQL or configuration examples.
Examples
Uses future bottleneck analysis, production-like staging, ecosystem tools, code reviews, and inherited-database assessment as practical examples.
What you can do after
Apply preventive planning, diagnosis, staged changes, monitoring, and incremental improvement to reduce PostgreSQL technical debt.

Read how PostgreSQL Mistakes and How to Avoid Them explains technical debt →

Designing AI Systems

Technical debt is the future cost of maintaining or changing a system because expedient implementation choices created structural limitations or rework.

How it is used
Diagnoses why disconnected AI application growth turns fast prototypes into expensive, fragile production work.
How deep it goes
Explains organizational causes and infrastructure consequences, but stops short of detailing a remediation implementation.
Examples
Contrasts a chatbot prototype with production demands and shows a minimal model call beside expanded GenAI infrastructure.
What you can do after
Evaluate why AI features become harder to build, deploy, and maintain when shared platform capabilities remain absent.

Read how Designing AI Systems explains technical debt →

Also covered in

What to know first

Related concepts

Questions about technical debt

What is technical debt?

Technical debt is the future cost, effort, or risk created by technical choices or deferred work that make a system harder to change, maintain, or operate.

Which Manning books explain technical debt?

Software Architecture Decision-Making, Vibe Engineering, Lead Developer Career Guide, Architecture Modernization: Socio-technical alignment of software, strategy, and structure, Think Like a Software Engineering Manager, Grokking Software Architecture, Delivering Machine Learning Projects: From design to deployment, Graph Neural Networks in Action and 8 more.

What should I know before learning technical debt?

Manning books that teach technical debt usually introduce contract, language model, refactoring and deployment pipeline first.

What is the difference between technical debt and comprehension debt?

Technical debt is the future cost, effort, or risk created by technical choices or deferred work that make a system harder to change, maintain, or operate. Comprehension debt is the accumulated gap between the complexity of software and its maintainers’ understanding of its architecture, assumptions, and behavior.

What is technical debt also called?

Technical debt is also called tech debt.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.