Fundamentals

What Is SDLC? 6 Phases and 3 Software Development Models

Planning wall with a hand-drawn circular diagram showing the 6 SDLC phases and SDLC in the center, blank sticky notes and markers in sunlight
In this article

    Suppose your shop has just hired a team to build its online store. Launch day comes, and you excitedly send the link to your customers. The first order arrives — but the customer calls: they tap “Checkout” and nothing happens. You message the web team, who reply: “Checkout wasn’t in the original requirements.” But you clearly remember discussing it from the very first meeting.

    This happens easily, and usually nobody was careless. It happens because the two sides never agreed on exactly what needed building: which requirements were settled, where they were written down, and who would check each feature before launch. To prevent that, people split a project into clear steps — and that way of splitting has a name: SDLC. This article explains what SDLC is, the 6 phases it covers, and 3 common models (Waterfall, Agile, Spiral) that arrange those phases differently.

    What is SDLC?

    SDLC (Software Development Life Cycle) is a structured process that takes software from an initial idea to a running product that gets maintained. Simply put, it’s the list of things a piece of software has to go through, and each step produces a concrete result both sides can check against. For the shop above, if checkout had been written into the requirements from the start and tested before launch day, neither side would have had to argue.

    SDLC is usually split into six phases, which I’ll walk through in the next section. One thing to keep in mind: SDLC only says what work has to happen. What order it happens in, and how often it repeats, is decided by models like Waterfall, Agile and Spiral — covered at the end of the article.

    What do the 6 phases of SDLC cover?

    Let’s stay with the online shop. The six phases of SDLC can be pictured through building a store website like this one:

    1. Planning and requirements: Work out what problem the website needs to solve and what features it needs. For example, customers need to browse products, add items to a cart, place an order and pay. The output is a list of requirements clear enough for the development team to know what they have to build.
    2. Design: Decide how the website is put together before writing any code. The team designs the database that stores products and orders, lays out the pages, and works out how those pieces fit together. The output is a design the build can follow.
    3. Implementation: Turn the design into working software by writing code. The product browsing, cart and checkout features are built in this phase. The output is a version of the software that can run and be tested.
    4. Testing: Check whether the features work as required. For instance, when a customer orders two products, the system must store the right quantity and calculate the right total. The output is the test result, plus a list of bugs to fix if there are any.
    5. Deployment: Put the tested version somewhere customers can use it. For the online shop, this is when the website goes up on a server and becomes reachable through its domain name. The output is the released version.
    6. Maintenance and Operations: Watch the website after it goes live, fix bugs as they appear, and update it when new requirements come in. For example, the shop might want to add a payment method, or need a fix for orders not being saved. The output is bug fixes, updates, and a record of how the system is running.

    One detail worth noting is that every phase has an output you can check: you can look at whether the requirements list is complete, compare the design, try a feature, or check whether a version has actually been released.

    That gives the development team a basis for knowing where the work stands and what is still missing. It’s also the foundation for organising the different SDLC models.

    SDLC models: Waterfall, Agile, Spiral

    Waterfall, Agile and Spiral all use the same phases above — they differ only in the order and how they repeat. For the shop from the start of the article, the three approaches differ like this:

    Waterfall

    Finish one step before moving to the next. The team settles all of the shop’s requirements, designs the whole website, and only then starts writing code.

    Diagram of the Waterfall Model with 6 cascading steps and a feedback loop
    Waterfall Model: each step finishes before the next begins.

    Agile

    Split the work into short cycles — sprints in Scrum, for example — with each cycle taking a small piece through all the phases. The first cycle might build only product browsing and the cart so the shop owner can try it out, and checkout gets added in a later cycle.

    Diagram of the Agile Development Model with 6 stages repeating around a loop
    Agile Development Model: six stages repeat — each cycle makes the product a little better.

    Spiral

    Work through several rounds, tackling the biggest risk first in each one. If it’s unclear whether the website can connect to the payment gateway the shop uses, the team tests that part on its own before building further.

    Diagram of the Spiral Model with 4 quadrants over 3 concentric rings
    Spiral Model: each loop passes through four quadrants — tackle risks before moving on.
    ModelHow it runsSuits projects that
    WaterfallSix phases run in sequenceHave clear requirements that rarely change
    AgileRepeats the lifecycle through short sprintsHave requirements that may change and need frequent feedback
    SpiralRepeats through rounds, each handling a riskCarry high risk or many uncertainties

    There’s no single best model for every project. If the requirements are already clear, Waterfall can be a good fit. If you need to experiment and adjust often, Agile usually makes more sense. And when risk is the big issue, Spiral helps the team focus on spotting and reducing it, round by round.

    Conclusion

    Next time you hire someone to build a website or take on a software project, you can ask the team three questions: where are the requirements settled, and in which document; who tests everything before launch day; and which model does the team follow? Those three questions are enough to tell whether both sides have agreed on how the work will be done.

    If the software also includes an AI agent, this process is missing a few things — because the same question can get a correct answer from the agent today and a different one tomorrow. What needs to be added, I’ll cover in the next article about ADLC (Coming soon).

    Sources

    The references below were opened and checked on 19/11/2026. MicroPyramid is the source for the six phases, Waterfall and Agile. freeCodeCamp also splits the work into six steps but groups them differently (Requirement analysis, Planning, Design, Development, Testing, Deployment — no maintenance).

    Assistant Gnurt

    Full-stack developer

    Discuss your project

    Comments

    No comments yet. Be the first!