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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- Grokking Statistics
- Machine Learning Platform Engineering
- Architecting an Apache Iceberg Lakehouse
- Machines that ThinkIn early access (MEAP)
- Shipping Go: Develop, deliver, discuss, design, and go again
- Crack Any Codebase with AIIn early access (MEAP)
- Practices of the Python Pro
- The Creative Programmer
- Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
- Grokking Web Application Security
- Effective Platform Engineering
- Clean Applications with Hexagonal ArchitectureIn early access (MEAP)
What to know first
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- refactoringRefactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
Related concepts
- refactoringaddressed by · Refactoring is the disciplined restructuring of existing software to improve its internal qualities while preserving its externally observable behavior.
- Boy Scout Ruleaddressed by · The Boy Scout Rule is a software maintenance practice of leaving code cleaner than it was found by making small improvements while changing it.
- pair programmingaddressed by · Pair programming is a software-development practice in which two programmers collaborate on the same programming task or code, often sharing coding and review responsibilities.
- code duplicationproduced by · Code duplication is the presence of the same or substantially similar implementation logic in multiple locations within a software system.
- comprehension debtcontrasts with · Comprehension debt is the accumulated gap between the complexity of software and its maintainers’ understanding of its architecture, assumptions, and behavior.
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.















