Maintenance &amp; LTS

Major Version Upgrade

Bump a major dependency or framework (e.g. React 17→18, Node 16→18) without melting production.

Minor & Patch Upgrade

Apply non-breaking minor/patch releases continuously to stay close to HEAD and reduce upgrade debt.

Breaking Change Handling

Identify, classify, and absorb breaking changes from upstream releases without a fire drill.

Upgrade Strategy & Cadence

Decide how often, in what order, and with what process you upgrade — the policy that makes upgrades routine, not heroic.

Rollback Plan

Make every upgrade instantly reversible — the safety net that lets you upgrade aggressively without fear.

Dependency Audit

Periodically inventory every dependency: what's used, what's unused, what's risky, what's outdated.

Dependency Update Strategy

Choose between Renovate, Dependabot, manual, or none — and configure the winner to match your risk appetite.

Lockfile Management

Commit, resolve conflicts, and keep lockfiles healthy so installs are reproducible and fast.

Supply Chain Security

Defend against malicious packages, typosquatting, account takeover, and the npm install foot-gun.

Dependency Deduplication

Collapse duplicate versions of the same package so you ship one copy, not five, of lodash.

Debt Identification

Surface the shortcuts, workarounds, and decay in your codebase before they become emergencies.

Debt Prioritization

Rank debt by interest rate (how fast it compounds) and principal (cost to pay), not by what's loudest.

Refactoring Patterns

Apply proven refactoring moves — extract, inline, move, introduce parameter — that are behavior-preserving and testable.

Debt Payment Strategy

Decide how much capacity to spend on debt vs features, and how to structure paydowns so they stick.

Debt Tracking & Metrics

Measure debt objectively with trend lines so paydown is visible and the policy is data-driven.

Database Migration

Evolve your schema with versioned, reversible migrations that deploy without downtime.

API Migration

Version and migrate your API without breaking existing clients — deprecate, shadow, then cut over.

Framework Migration

Replace one framework with another (e.g. Express→Fastify, Vue 2→3) incrementally, not in a big bang.

Data Migration

Move bulk data between systems (DB→DB, format→format) with verification and zero loss.

Migration Rollback

Make every migration reversible — the safety net that lets you migrate aggressively and recover from failure.

Deprecation Policy

Define how, when, and why you deprecate — the rules that make retirement predictable for users.

Sunset Timeline

Communicate the deprecation-to-removal timeline so clients can plan migrations with confidence.

User Communication

Tell users about deprecations and breaking changes through the channels they actually read.

Migration Path

Provide a concrete, copy-pasteable path from the deprecated thing to its replacement.

Breaking Change Process

The end-to-end process for shipping a breaking change safely — from decision to sunset to removal.

LTS Policy

Define which releases are LTS, how long they're supported, and what "support" means (security only vs. bug fixes).

Support Tiers

Define tiers (e.g., LTS / current / beta / EOL) so users know what support level they're getting.

End-of-Life (EOL)

Declare and communicate the end of support for a version, with a clear upgrade path and a grace period.

Security Backports

Backport security fixes from the current release to LTS versions so staying on LTS doesn't mean being vulnerable.

Compatibility Maintenance

Keep your software working with the ecosystem (Node versions, OS, browsers, deps) it claims to support.

Vulnerability Response

The end-to-end process when a vulnerability is reported or discovered — from triage to fix to disclosure.

Patch Priority

Rank patches by severity and exploitability so critical fixes ship first and cosmetic ones wait.

CVE Tracking

Track CVEs that affect your dependencies, map them to your exposure, and verify fixes land in your lockfile.

Hotfix Process

Ship a critical fix outside the normal release cadence — fast, safe, and with a post-mortem.