Back to writing

Product Management

Maintenance Phase in SDLC: Types, Steps and an Example

NOV 19, 2026 10 MIN READ

The maintenance phase in SDLC is the last of the seven SDLC phases. It starts when the deployment phase hands over a live system and ends when someone switches the software off.

Everything that happens to the software after release lands here, and what users ask for becomes the next backlog for planning.

The example is the made-up invoicing tool for a plumbing firm that runs through the series.

What the maintenance phase is for

The maintenance phase exists to keep software useful while it's in operation, and most of the work in it is changing the software rather than repairing it.

SWEBOK, the IEEE Computer Society's guide to the field, defines software maintenance as "the totality of activities required to provide cost-effective support for software in operation."

People hear maintenance and think of bug fixes. SWEBOK says studies and surveys over the years have indicated that over 80% of maintenance goes into enhancing and adapting the software.

It's normally the longest phase too. SWEBOK puts a typical development project at months to a few years, and says the maintenance phase usually lasts until the software is retired.

Inputs and deliverables of the maintenance phase

The maintenance phase takes in the live system plus a steady flow of reports and requests, and turns them into patches and the next backlog.

  • From deployment - A live system, its release notes, the on-call runbook and the monitoring dashboard.

  • From users - Problem reports and requests for changes.

  • From outside - Security advisories on dependencies, notice that a vendor is retiring an API version, and rule changes such as a new tax rate.

The deliverables are patches with release notes, a regular report on errors and uptime, a ranked backlog for the next planning phase and, at the very end, a plan to retire the system.

Who leads the maintenance phase

Ops and the Product Manager lead the maintenance phase together, with Ops keeping the system running and the PM deciding what changes next.

On-call and uptime belong to Ops. Triage priority and the backlog belong to the PM.

Engineers make the fixes, ideally the people who built the system. QA, or whoever owns the test suite, runs the regression tests.

Users report what's wrong. The business owner decides how much maintenance to pay for and when to retire the system.

The types of maintenance in SDLC

The types of maintenance in SDLC sort each change by the reason for it: a fault to fix, a fault to prevent, an environment that changed, or a product that should do more or do it better.

Many guides list four types. SWEBOK V4.0a, released in August 2026, lists five standardized categories and says ISO/IEC/IEEE 14764, the international standard for software maintenance, defines a sixth for emergencies.

TypeWhat it coversThe invoicing tool
CorrectiveRepairs after release to correct problems someone foundA wrong total on invoices with a discount line
PreventiveCorrecting latent faults before they occur in the live systemA rounding error in the tax logic, caught before any invoice hits it
AdaptiveKeeping the software usable as its environment changesThe payment provider retires the API version the tool calls
AdditiveAdding functions or featuresRecurring invoices
PerfectiveEnhancements for users, better documentation, recoding for performance or maintainabilityA faster job list, a clearer runbook
EmergencyAn unscheduled change that keeps the system running until the corrective fixSwitching the payment link off behind a feature flag

SWEBOK says ISO/IEC/IEEE 14764 groups the categories into corrections and enhancements, and warns that putting the two together in management reports helps make corrections look more expensive than they are. I'd report them on separate lines.

Steps in the maintenance phase

Every change in the maintenance phase goes round the same five steps, and the loop repeats until the software is retired.

  1. Watch. Monitoring, alerts and user reports tell you something has changed.

  2. Log and triage. Each problem report or change request gets logged with a type and a severity, and someone works out what else the change will touch.

  3. Fix and regression test. SWEBOK describes regression testing as the selective retesting that checks a change hasn't caused unintended effects. A patch without one is a guess.

  4. Release a patch. It goes out with release notes, plus the back-out plan SWEBOK asks for at release planning.

  5. Report and feed the backlog. The regular report goes to the owner, and anything bigger than a fix goes on the backlog for the next planning phase.

The maintenance loop: from deployment, watch, log and triage, fix and regression test, release a patch, then report and feed the backlog, repeating until the software is retired.The maintenance loop: from deployment, watch, log and triage, fix and regression test, release a patch, then report and feed the backlog, repeating until the software is retired.

An original diagram, free to reuse with a link to this page · Download the SVG

The diagram as text
  • Deployment hands over the live system and the runbook.
  • Watch: monitoring, alerts and user reports.
  • Log and triage: each request gets a type and a severity.
  • Fix and regression test.
  • Release a patch, with release notes and a back-out plan.
  • Report and feed the backlog, then watch again, until the software is retired.

Some maintenance work comes from the calendar instead of a ticket. Node.js says its LTS releases typically get critical bug fixes for a total of 30 months, and that production applications should only use Active LTS or Maintenance LTS releases.

Maintenance in agile versus waterfall

In waterfall, maintenance is a separate phase that begins after handover, sometimes with a different team. Agile puts it in the same backlog as new features, which is one of the differences between agile and waterfall a team lives with longest.

A new team taking over starts by learning the code. SWEBOK cites research suggesting a significant portion of total maintenance effort goes into understanding the software being changed.

Many agile and DevOps teams answer that by keeping the builders responsible. Werner Vogels, Amazon's CTO at the time, described the old model to Jim Gray in a 2006 ACM Queue interview as throwing software over the wall between development and operations and forgetting about it. Amazon's answer, he said, was "You build it, you run it."

The catch is the backlog. SWEBOK notes that in an agile setting, maintenance has to compete with new features for the client's approval at the end of each iteration.

I'd give maintenance a fixed share of each sprint and let the PM spend it, so a fix never has to beat a feature to get scheduled.

The invoicing tool in the maintenance phase

The invoicing tool enters maintenance once the whole firm is on it and the fortnight with the old Word template is over.

Ops runs it from the runbook and sends the firm's owner a monthly report on errors and uptime. The dashboard from deployment already tracks the success measure from the planning brief, days from job complete to payment received, and I'd put that number in the report too.

Four changes reach the log in the first months.

  • Corrective - An invoice for a job with a discount line shows the wrong total. The fix ships with a new unit test on the totals logic, so the bug can't come back unnoticed.

  • Emergency, then corrective - A patch breaks the payment link. Ops switches the link off behind a feature flag, invoices keep going out as PDFs by email, and the real fix follows.

  • Adaptive - The payment provider announces it will retire the API version the tool calls. Ops puts the upgrade on the calendar ahead of the cut-off.

  • Additive - The office manager asks for recurring invoices and a reminder when an invoice goes overdue.

Those two requests are the next backlog. The PM writes them up as stories for a healthy product backlog and ranks them against the success measure. If customers are still taking weeks to pay, the overdue reminder goes first.

Common mistakes in the maintenance phase

The mistakes I'd fix first in the maintenance phase are leaving it out of the budget and letting requests disappear before they reach the backlog.

  • No plan for maintenance - SWEBOK says maintenance planning should begin with the decision to develop a new product. A business case that covers only the build leaves out what is usually the longest phase.

  • Ignored dependency updates - GitHub says that when maintainers stop interacting with Dependabot's pull requests, Dependabot temporarily pauses its updates and lets you know.

  • Requests that die in an inbox - Log every user request and tell the user what happened to it. That last step is what closes a product feedback loop.

  • A dead system on life support - Retirement belongs to this phase too. When users have moved to a substitute, the product is in the decline stage, and I'd plan its exit and stop paying for patches.

What AI changes in the maintenance phase

AI tools in the maintenance phase draft root causes and fixes for production errors and security alerts, and the ones named here hand that draft to a person to review.

Sentry's Seer runs Autofix from a root cause analysis to a proposed fix and, if you allow it, a pull request. With automation on, Sentry can start it by itself on an issue seen in the last 14 days, once the issue has 10 or more events and its model rates it fixable enough. You can cap it to stop after the root cause, after the plan or after a drafted PR.

GitHub offers two autofix experiences for code scanning alerts. Copilot Autofix suggests one change for one alert and is on by default in repositories that use CodeQL. Agentic autofix opens a draft pull request and uses AI credits and Actions minutes.

GitHub's responsible-use page warns that a suggested fix can be syntactically valid and still change what the program does, and can include fabricated dependencies published under statistically probable names.

PagerDuty AI drafts post-incident reviews, follow-up actions included, and PagerDuty says you must fact-check generative AI output before you use it.

I'd start Seer at the stop-after-plan setting and compare its root causes with your own for a few months before letting it open pull requests. Whoever approves an AI-drafted fix needs to read code well enough to see when a fix changes behavior.

An AI agent you run yourself brings maintenance of its own, and evals, monitoring, model swaps and prompt versioning are among the hidden costs of AI implementation that a build budget leaves out.

A maintenance phase checklist

Run this maintenance phase checklist on any live system you're responsible for.

  • Someone is on call, with the runbook from deployment.

  • Every request is logged with a type and a severity.

  • Corrections and enhancements are reported on separate lines.

  • Every patch has a regression test and a back-out plan.

  • Runtime and dependency end-of-support dates are on a calendar.

  • The regular report carries the success measure from planning.

  • There's a written trigger for retiring the system.

Share this post

RELATED READING

FREQUENTLY ASKED

What is the maintenance phase in SDLC?
It's the last of the seven SDLC phases. It starts when deployment hands over a live system and lasts until the software is retired. The team fixes faults, adapts the software as its environment changes, and turns user requests into the next backlog for planning.
What are the types of maintenance in SDLC?
Many guides list four: corrective, adaptive, perfective and preventive. SWEBOK V4.0a, the IEEE Computer Society's guide, lists five standardized categories, those four plus additive maintenance for new features, and says ISO/IEC/IEEE 14764 also defines a sixth, emergency maintenance.
What happens in the maintenance phase of SDLC?
The team watches the live system, logs and triages each problem report or change request, fixes it with a regression test and releases a patch. A regular report goes to the owner, and anything bigger than a fix goes on the backlog for the next planning phase.
Back to writing