The SDLC (software development life cycle) is the process a team follows to build or change software: plan it, design it, write it, test it, release it. ALM (application lifecycle management) is the wider job of managing that application for its whole life, from the business case to the day it is switched off, and it contains the SDLC, usually several times over. The SDLC answers "how do we build and ship this version?" ALM answers "who owns this application, what does it cost to keep, and when does it end?"
For a short project the two look almost identical. The difference shows up after launch, when the team that built the software moves on and the application keeps running for years, collecting data, integrations and users along the way.
ALM and SDLC side by side
| SDLC | ALM |
|---|---|---|
Question it answers | How do we build and ship this change? | Why does this application exist, who owns it, and when does it end? |
Starts | When a project or release is approved | When someone first proposes the application |
Ends | When the release is in production | When the application is retired and its data archived or deleted |
Runs | Once per project, release or sprint | Once per application, across every project and team that touches it |
Owned by | Engineering lead or project manager | Product or application owner with a budget |
Main outputs | Requirements, design, code, tests, a release | Business case, roadmap, release history, support terms, a retirement plan |
Typical tools | Git, CI, test frameworks, an issue tracker | The same, plus requirements, portfolio and service management |
The line is blurrier than vendor diagrams suggest. The international standard for software life cycle processes, ISO/IEC/IEEE 12207, covers operation, maintenance and disposal alongside development, and its second edition, published in April 2026, keeps that scope. So when someone says "SDLC" they may well mean the whole life, and "ALM" is often the word vendors use to sell an integrated tool suite.
The distinction we find useful is about ownership. A team runs an SDLC for a project. An organization practices ALM for an application, across projects, teams and even vendors. AWS puts it the same way: one application can go through several SDLCs during its life.
One application, several SDLCs
Oplist, a client whose hospital shift-scheduling software we have been building since November 2023, shows what that looks like. When we took over the codebase there was already an early version written with Flutter Web and Flask, with an optimization model for the nurse rostering problem behind it. We rebuilt the front end in React and the API in Node.js on PostgreSQL, and we are still shipping releases with Oplist in 2026. It is used at five to ten locations and has generated schedules for more than 2,000 people.
So one application has been through at least two SDLCs: one produced the early version, the other rebuilt it, and each release since then runs through a smaller cycle of its own. What carried across is what ALM is about: the owner (Oplist itself), the optimization model and the rostering rules it encodes, and the data. The hardest part of the rebuild was time and data integrity, and no phase diagram warns you about that. New code passing its tests is the easy milestone. A rebuild is done when the old data and the old behavior have come across correctly.
Some of what has to survive comes from outside the application. Oplist exchanges data with private hospitals' HR and payroll systems through live API integrations. Those systems can contain duplicate staff records, and some leave types take precedence over others, so we deduplicate and apply a precedence order inside Oplist instead of trusting the source. A rule like that should be written down somewhere other than the code, because whoever rewrites or replaces that code next will need it too.
When the difference matters
For a three-month MVP built by one team, it mostly doesn't. You need a decent SDLC: a backlog, version control, automated tests and a repeatable release. Buying an ALM suite at that stage is overhead, and we would tell you to skip it.
It starts to matter when any of these is true:
- The application will outlive the team that built it, or another vendor will take it over.
- More than one team or company makes changes to it.
- You work in a regulated field, such as medical device software under IEC 62304, where an auditor will ask which test covered which requirement in which release.
- It stores personal data that will have to be deleted one day.
- You sell software products in the EU, which now have to declare how long they will be supported (more on that below).
What ALM adds to the SDLC
An owner and a one-page record
Every application needs a named owner who controls its budget, decides on changes and will one day decide when it ends. That owner keeps a short record: what the application is for, who uses it, what data it holds, which systems it talks to, where it runs and how long it is expected to live. It fits on one page and takes an hour to write. Without it, planning a retirement ten years later starts with archaeology.
Releases that operations can live with
Release management is where the SDLC hands over to operations, and where the two clash most often. A release process that holds up over years usually has these parts:
- Version numbers that mean something. For APIs and libraries, Semantic Versioning (MAJOR.MINOR.PATCH) tells the people integrating with you whether an update can break them.
- Release notes written for the people who use the software, in their language rather than the commit log's.
- A rollback plan you have tried before you need it. The database is usually the hard part: once a migration drops or renames a column, redeploying the old code won't bring it back. Ship schema changes in two steps instead, adding the new column first and removing the old one in a later release.
- Deployment separated from release, so code can reach production switched off behind a feature flag and be turned on when the business is ready.
- An automated pipeline, so Thursday's release is built exactly the way Tuesday's was. Our GitHub Actions guide covers a practical setup.
Maintenance: keeping up with what sits underneath
Bug fixes are the visible part of maintenance. A good part of the rest is adaptive work: the operating system, runtime, cloud platform and third-party APIs under the application keep changing, and the application has to change with them. A current example: Python 3.10 reached end of life on 1 October 2026, so any service still running on it no longer gets security fixes from the Python core team.
That work has to happen while people are using the system. On Diderot, the course platform developed at Carnegie Mellon University, we upgraded the AWS Elastic Beanstalk platform and the Python version and rebuilt the staging and production environments while courses were running on it. The first build of an application rarely has that constraint. Maintenance almost always does.
Maintenance also needs terms: how quickly a problem gets a response, who is on call, what counts as urgent. For two clients we have worked with for years, Method Procurement (since 2019) and FrontRunner Professional, our SLA is two days. Our post on support SLAs covers how to set those numbers for your own system.
AI components age faster than the code around them. The exercise program generator we built for a sports physiotherapy clinic started in 2023 with rules and Q-learning. In 2025 we rebuilt that engine as an LLM generator with retrieval over the clinic's library of more than 1,800 exercise entries, and the web app around it carried on. At Jenesys AI, custom models we built were later overtaken by frontier models. If part of your application is a model, assume that part will be replaced, possibly more than once, within the application's life. Two habits make the swap cheaper: keep the model behind a narrow interface that the rest of the application calls, and keep a set of past inputs with outputs a person has judged good, so a replacement can be compared before it goes live. For the clinic, we are adding stored AI-versus-coach comparisons in 2026 so the program logic can be checked against past athletes.
Retirement
Retirement is the stage almost nobody plans, so it usually happens by neglect: the application keeps running, unwatched, because nobody is sure what still depends on it. A planned retirement goes roughly like this:
- List everything that depends on the application: integrations, scheduled jobs, exports, reports, and the ways people use it that nobody wrote down.
- Decide what data must be kept, for how long and why, and delete the rest. The GDPR lets you keep personal data only as long as its purpose requires (the storage limitation principle in Article 5), while accounting and tax rules usually require some business records to be kept for a fixed number of years. The archive has to satisfy both.
- Run the old and new systems side by side, with an agreed, measurable test for when the new one is good enough.
- Make the old system read-only before switching it off, and leave it that way long enough for someone to notice what is missing.
- Remove access and cost: user accounts, API keys, DNS records, cloud resources and licenses. A forgotten server with working credentials is a security hole, and an unused subscription is money leaving every month.
- Archive the documentation with the data, so someone can still answer questions about it years later.
Step 3 applies to processes as well as systems. For Tribute Technology we built a platform to replace one-off manual imports of funeral homes' legacy data. While it was being built we carried out 11 conversions by hand so customer onboarding never stopped, and in February 2023 Tribute dropped manual imports for the automated process. Its product owner judged success by checking migrated data against accounts-receivable reports, case counts and spot checks. That is the kind of agreed, measurable test step 3 asks for.
The same engagement ended in a handover. In September 2023 we moved the production code into Tribute's own repositories and AWS account, with installation and architecture documentation, and kept maintaining it into 2024. Our part of the lifecycle ended there; the application's carried on.
If the plan is to replace an old system rather than switch it off, our guide to legacy system modernization covers the replatform-or-rebuild decision.
End dates are becoming public commitments
The EU's Cyber Resilience Act turns the support period into a legal obligation for products with digital elements: connected hardware and software products, apps and components among them, together with the remote data processing they rely on. Software offered purely as a service (SaaS) generally falls outside it, except where it is the remote data processing behind a covered product. Manufacturers must set a support period of at least five years (shorter only if the product is expected to be in use for less time) and state its end date, month and year, when the product is sold. Reporting of actively exploited vulnerabilities has applied since 11 September 2026, and the main obligations apply from 11 December 2027. If you sell software products into the EU, "how long will we support this?" is now a decision for the start of the lifecycle.
Vendors' end dates land on you too. Atlassian has set 28 March 2029 as the end of life for its affected self-hosted Data Center products, Jira among them, after which they become read-only. If your requirements, tickets and release history live in a self-hosted Jira, moving them out is a migration project with a lifecycle of its own.
Tools for each size of team
For a small team, the issue tracker, Git hosting and CI pipeline you already use are your ALM tools. GitHub or GitLab with a well-kept backlog covers most of what one application needs.
Jira or Azure DevOps start to pay off when several teams work on the same applications and need shared boards, permissions and reporting. In regulated work, requirements and traceability tools such as Polarion, Codebeamer or Jama Connect justify their cost because they produce the audit trail from requirement to test to release that a regulator asks for.
Spend less time choosing the tool than writing the one-page record. No tool fills that in for you.
Frequently asked questions
Is the SDLC part of ALM?
Yes. ALM covers the application's whole life, and each project or major release within that life runs through an SDLC. A long-lived application can go through several.
Is ALM the same as DevOps?
No. DevOps is a way of working that brings development and operations together through practices such as continuous delivery and shared on-call. ALM is the management scope those practices sit inside, and it also covers the business case, ownership and retirement.
What is the difference between ALM and PLM?
PLM (product lifecycle management) manages physical products: designs, bills of materials, engineering changes. ALM manages software. Companies that make hardware with embedded software often run both and link them.
Which SDLC models does ALM work with?
Any of them. Waterfall, the V-model, spiral, iterative models and agile methods such as Scrum are all ways of running the SDLC. ALM sits above whichever one the team uses.
What are the stages of ALM?
Sources group them differently. A common split is governance (business case, ownership, retirement), development (the SDLC) and operations (release, monitoring, maintenance). AWS lists five: requirements gathering, development, testing, deployment and maintenance.
If you are taking over an application someone else built, or need a team to keep one healthy for years, that is the work our maintenance and support team does.
Related Articles
WMS vs TMS: What Each Does and Which One You Need First
A WMS runs what happens inside the warehouse; a TMS runs what happens after the truck leaves. Where they meet, which to buy first, and when you need neither.
Read More: WMS vs TMS: What Each Does and Which One You Need FirstSaaS Pricing Models: How to Choose One and Bill for It
The main SaaS pricing models, when each one fits, and the decision to make first: your value metric. Plus what your pricing asks of the billing code.
Read More: SaaS Pricing Models: How to Choose One and Bill for ItSaaS Metrics: What to Track, How to Calculate It, What Good Looks Like
The core SaaS metrics with formulas and worked examples, what recent benchmarks say is normal, and the definition mistakes that quietly distort MRR, NRR and LTV.
Read More: SaaS Metrics: What to Track, How to Calculate It, What Good Looks Like
