Chapter 1 · How Software Gets Built
The Software Development Life Cycle (SDLC)
- Page 2 of 18
- 16 min read
On the first page, What Software Engineering Is, and Why Coding Is Not Enough, you saw that a software engineer does much more than write code: understanding the problem, planning, designing, testing, releasing and maintaining. Those activities are not a random list. Each one needs something from the one before it and hands something to the one after it. Put in order, they are called the software development life cycle, or SDLC.
This page walks through the SDLC for ClinicQueue: what each activity is for, what it takes in and what it produces, who does the work, and how to decide at the very start whether the project should go ahead at all. It ends with an important warning: real projects rarely move through these activities once, in a neat line.
What you will learn
- The seven activities of a common SDLC convention, from planning and feasibility to maintenance.
- What each activity takes in and what document or other artefact it produces, using ClinicQueue.
- How to run a short feasibility check (technical, cost, time, legal and operational) and reach a go or no-go decision.
- Who on the team leads and who helps at each activity.
- Why the activities overlap and repeat in practice, and why that leads to different process models.
The SDLC as a set of activities
The SDLC describes the work needed to take software from an idea to something people use, and then to keep it useful. There is no single official list of SDLC phases. Textbooks and companies use different names and split the work in different ways. The seven activities below are a common convention, and they are what this tutorial uses.
| Activity | The question it answers | ClinicQueue example |
|---|---|---|
| Planning and feasibility | Should we build this, and can we? | Lena checks that a small team can deliver online booking within the clinic's budget and the privacy rules |
| Requirements | What exactly must the software do, and how well? | "A patient can book a free slot up to 14 days ahead"; "the queue screen updates within 5 seconds" |
| Design | How will the software be built: which parts, data and screens? | A booking module, a reminder module, a queue screen and the tables that store appointments |
| Implementation | Writing the code that follows the design | Aiko builds the booking form; Farhan writes the code that saves bookings |
| Testing | Does it do what was agreed, and does it fail safely? | Kwame tries to book the same slot from two phones at once |
| Deployment | How does a version reach real users safely? | Version 1.0 is installed on the server on a quiet afternoon, with a plan to undo it if needed |
| Maintenance | How do we keep it working and useful after release? | Fixing a holiday-date bug; later adding the AI reminder draft |
Two words in the table need a definition. Implementation is the usual SDLC name for writing the code. Deployment means putting a version of the software where its users can reach it, such as a server, an app store or the clinic's computers.
Notice that maintenance is part of the cycle, not something after it. Most useful software lives far longer than the time it took to build the first version, so the cycle repeats: a change request in maintenance starts with a small piece of planning and requirements again.
Example:
Planning and Requirements Design Implementation
feasibility ---> ---> --->
^ |
| v
Maintenance <--- Deployment <--- Testing <-----------+
|
+--- a bug report or a new idea starts a smaller cycle againInputs and outputs of each activity
Each activity turns something it receives (its input) into something the next activity can use (its output). Outputs are often called artefacts: any document, model, code, test or other work product that the team creates and keeps. Artefacts matter because they let people who were not in the room continue the work. If the requirements exist only in Farhan's head, Kwame cannot test against them.
| Activity | Main inputs | Main outputs (artefacts) | ClinicQueue artefact |
|---|---|---|---|
| Planning and feasibility | The customer's problem, budget, deadline | Feasibility check, go/no-go decision, first rough plan | One-page feasibility note signed off by Nadia |
| Requirements | Feasibility note, interviews, observation of users | Requirements list or specification, acceptance criteria | "Requirements v1": 20 requirements, each with a way to check it |
| Design | Requirements | Architecture sketch, data model, screen designs | Component diagram, ER diagram, Omar's booking-screen mock-ups |
| Implementation | Design, requirements | Source code, unit tests, short code notes | The booking and reminder code in a shared repository |
| Testing | Requirements, acceptance criteria, built software | Test cases, test results, bug reports | Kwame's test list and a report: 2 open bugs, both minor |
| Deployment | Tested version, release checklist | A running release, release notes, rollback plan | "ClinicQueue 1.0" live, with notes for Rina |
| Maintenance | Bug reports, user feedback, new needs | Fixes, small new versions, updated documents | Version 1.0.1 fixes the holiday-date bug |
Read the table down the "Main inputs" column and you see the chain: every input is an output of an earlier row. When an artefact is missing or poor, the next activity has to guess, and guesses become bugs. Testing is the clearest example. A tester can only check what was agreed, so vague requirements make testing weak.
How detailed should each artefact be? Practitioners disagree. Some teams write a full requirements specification of many pages before any design starts; others keep a short list and talk often. Both can work. The useful question is: who will read this artefact, and what will go wrong if it is missing? For ClinicQueue, a short list of requirements with clear acceptance criteria is enough at first, but the decision about how patient data is stored must be written down carefully, because it affects privacy and will be checked later.
Feasibility: should we build this at all?
A feasibility check is a short study, at the start, that asks whether the project is possible and worth doing. It does not need to be long. Its job is to catch a "no" before anyone spends weeks on design and code. The common kinds of feasibility are these.
| Kind | The question | ClinicQueue check |
|---|---|---|
| Technical | Can we build it with the skills, tools and technology we have? | Web booking and SMS sending are well-known problems; the team has built web forms before |
| Cost | Is the expected value greater than the cost to build and run it? | Build effort, server hosting and a fee per SMS, against fewer phone calls and fewer missed visits |
| Time | Can it be ready when it is needed? | Nadia wants online booking before the clinic's busy season in 6 weeks |
| Legal | Does it respect the laws and contracts that apply? | Patients' names and phone numbers are personal data; consent and storage rules must be checked |
| Operational | Will people actually use it in their daily work? | Will Rina use the queue screen at a busy desk? Do most patients have a phone that receives SMS? |
Here is how the check went for ClinicQueue. The numbers are invented.
Invented scenario:
Lena spends two days on a feasibility check before the team commits.
Technical OK. Booking forms and SMS sending are common. One unknown: the SMS service
the clinic can afford. Farhan builds a 1-day test that sends 5 messages.
Cost OK. About 10 person-weeks for the first release, plus hosting and SMS fees.
Nadia expects fewer missed visits and a free phone line in the morning.
Time RISKY. With two developers (Farhan, Aiko) that is about 3-4 weeks of building,
and testing, fixes and training push it close to the 6-week deadline.
Legal CONDITION. Patient data must be stored privately, and patients must agree to
receive SMS. Nadia will confirm the local data protection rules.
Operational OK with a condition. Rina is willing, but walk-in patients must still be
added to the queue by hand. Patients without SMS keep phone booking.
Decision GO, with three conditions: confirm the data rules, keep phone booking,
and release booking first, reminders second, if time runs short.Notice three things. First, the result is not just "yes" or "no". "Go with conditions" is common and useful. Second, the check found real requirements early: walk-in patients and phone booking for people without SMS. Third, the time risk produced a plan (booking first, reminders second) before any code was written. That idea, delivering the most important part first, comes back on the next page, Process Models: Waterfall, Incremental, RAD and Big Bang.
You can reuse this check on any project, including a freelance job.
Template:
FEASIBILITY CHECK Project: ______________ Date: ____-__-__
Kind Question Result (OK / RISKY / NO) Notes
------------ --------------------------------------------- ------------------------ -----
Technical Can we build it with our skills and tools?
Cost Is the value greater than build + running cost?
Time Can it be ready when it is needed?
Legal Which laws, contracts or data rules apply?
Operational Will the real users use it in their daily work?
Any NO -> stop, or change the idea and check again
Any RISKY -> write a condition or a plan for it
Decision: GO / GO WITH CONDITIONS / NO GO Agreed by: ______________A feasibility check is not legal advice and does not replace one. When a project stores personal or health data, the right step in the "Legal" row is often "ask someone who knows the local rules", and writing that down as a condition.
Who is involved at each activity
Every activity has someone who leads it, but almost none is done by one person alone. The table shows who led and who helped on ClinicQueue. Project Management and the Roles in a Software Team will turn this into a proper responsibility table; for now, notice how often the customer and the users appear.
| Activity | Leads | Also involved | Why they are there |
|---|---|---|---|
| Planning and feasibility | Lena | Nadia, Farhan | Nadia knows the budget and the deadline; Farhan judges what is technically possible |
| Requirements | Lena | Nadia, Rina, Dr. Rahman, patients, Omar, Kwame | Users know the real work; Kwame asks "how will we check this?" early |
| Design | Farhan (system), Omar (screens) | Aiko, Kwame, Rina | Rina tries paper mock-ups of the queue screen; Kwame looks for parts that are hard to test |
| Implementation | Farhan, Aiko | Omar, Kwame | Omar answers design questions; developers review each other's code |
| Testing | Kwame | Farhan, Aiko, Rina, Nadia | Developers fix and retest; Rina and Nadia check that it fits the clinic's real work |
| Deployment | Farhan | Lena, Kwame, Rina | Lena picks a quiet time; Kwame checks the live version; Rina is trained |
| Maintenance | Whole team | Nadia, users | Users report problems and ideas; Nadia decides what is worth changing |
A common mistake is to see testing as "Kwame's job at the end". On ClinicQueue, Kwame joins the requirements meetings, because a tester asking "how would I check that?" turns vague wishes into testable requirements. In the same way, Farhan joins feasibility, because a quick technical test is cheaper than a wrong promise.
Activities are not always strict phases
The diagram above looks like a line of separate steps, each finished before the next begins. Real projects rarely work like that. Activities overlap, and the team often goes back to an earlier one when it learns something new. Here is what actually happened during ClinicQueue's first release, which took about 6 weeks.
Example:
Week: 1 2 3 4 5 6
Feasibility ###
Requirements ########## ###
Design ########## ####
Implementation ########### ##########
Testing ############ ###########
Deployment ### ###
Week 2-3: coding the booking form starts while the reminder design is still open.
Week 4: testing finds that walk-in patients break the queue order -> back to
requirements and design for a short time.
Week 4 and 6: a small trial release for the clinic, then the first release itself.This is normal, and it is not a failure of planning. Some things can only be learned by building and testing: how long the SMS service really takes, or whether Rina can read the queue screen from across the desk. The question is not whether activities will overlap and repeat, but how the team organises that on purpose.
Different answers to that question are called process models. One model tries to finish each activity before the next begins. Others deliver the software in small parts and repeat the whole cycle for each part. Others again build quick prototypes to learn fast. Each fits some projects better than others, and choosing well is a real engineering decision. That is the subject of the next page.
Where this shows up at work
- Project proposals and quotes for clients are often organised by SDLC activity: requirements, design, build, test, deployment and a period of support.
- Job roles map to activities: business analysts in requirements, architects in design, testers in testing, operations or DevOps staff in deployment and running. Knowing the whole cycle helps you work with all of them.
- Regulated fields such as health and finance often expect evidence for each activity, such as approved requirements and test results, so artefacts matter even more there.
- Freelancers who do a one-hour feasibility check before quoting avoid jobs that are impossible on the client's budget or deadline.
Common mistakes
- Skipping feasibility because the idea feels obvious. It bites when a legal or operational problem appears after weeks of coding, such as missing consent for SMS. Fix: spend an hour or two on the five feasibility questions and write the answers down.
- Treating the seven activities as an official standard. It bites in discussions with teams that use other names, and it hides the real point. Fix: treat the list as a convention; what matters is that each activity's work is done and its outputs exist.
- Producing artefacts nobody uses. A long document that no one reads costs time and still lets mistakes through. Fix: for each artefact, name who will use it and for what; keep it as short as that use allows.
- Forgetting maintenance in the plan. The first release goes out, then bug reports arrive and nobody has time for them. Fix: plan who handles fixes and changes after release, and for how long, before the project starts.
- Bringing users and testers in only at the end. Problems that users or testers would have seen early are found late, when they are harder to fix. Fix: involve them from requirements onwards.
Try it yourself
- Easy: For each ClinicQueue artefact, name the SDLC activity that produces it: (a) a bug report saying the queue screen shows yesterday's patients; (b) Omar's mock-up of the booking screen; (c) release notes for version 1.1; (d) the sentence "A patient can cancel a booking up to 2 hours before the visit"; (e) a one-page note that says "GO, with conditions".
- Medium: Nadia now wants the AI feature: an AI model drafts the SMS reminder text, and Rina checks it before it is sent. Write a short feasibility check for this feature using the five kinds (technical, cost, time, legal, operational). Give each one a result (OK, RISKY or NO) with a one-line reason, and end with a decision.
- Hard: Two weeks after version 1.0 is released, Rina reports that patients who book for a child cannot enter the child's name; the form only allows the phone owner's name. Trace this change through the SDLC: for each activity, say what must be done or updated, which artefact changes, and who is involved. Then say which earlier activity probably missed this need, and what could have caught it.
Answers
- (a) Testing (or maintenance, if a user reported it after release): bug reports are a testing output. (b) Design: screen mock-ups are a design artefact. (c) Deployment: release notes go out with a version. (d) Requirements: it is a requirement with a clear, checkable rule. (e) Planning and feasibility: the go/no-go decision is its main output.
- Model answer: Technical: RISKY, the team has not used an AI model before and must test how reliable the drafts are. Cost: OK, if the cost per draft is small compared with the time Rina saves; check the provider's price first. Time: OK, it is not needed for version 1 and can be planned for a later release. Legal: RISKY, sending patient names or details to an outside AI service may need patient consent and must follow the data rules; send as little personal data as possible. Operational: RISKY, Rina must check every draft, so the feature only helps if checking is faster than writing. Decision: GO WITH CONDITIONS, run a small trial with invented patient data, confirm the data rules, and keep the human check. A good answer covers all five kinds, notices the privacy issue and the human check, and does not say "OK" to everything without a reason.
- Model answer: Planning: Nadia agrees it is worth doing now; a small change, so no full feasibility check. Requirements: Lena adds "A booking can be for another person; the form asks for the patient's name and the contact phone separately", with acceptance criteria; Rina and Nadia confirm it. Design: Farhan updates the data model so a booking stores a patient name and a contact phone; Omar changes the form design. Implementation: Aiko changes the form, Farhan the stored data; both review each other's change. Testing: Kwame adds test cases (booking for a child, two children with the same phone) and reruns the old tests. Deployment: a new minor version with release notes for Rina. Maintenance: the change is recorded so future work knows why bookings have two names. The need was probably missed in requirements: the team talked to the customer and the receptionist but not enough to patients. Observing real bookings for a morning, or asking "who else books on someone's behalf?", could have caught it. A good answer touches every activity, names a concrete artefact for each, and points to requirements as the root, not to coding.
Summary
- The SDLC is a common convention, not a single official standard: planning and feasibility, requirements, design, implementation, testing, deployment and maintenance.
- Each activity turns inputs into artefacts that the next activity uses; a missing or vague artefact turns into guesses and bugs later.
- A short feasibility check (technical, cost, time, legal, operational) can stop a bad project early or turn risks into clear conditions.
- Every activity has a lead, but customers, users and testers belong in many of them, especially requirements.
- In real projects the activities overlap and repeat; how a team organises that is its process model.
Next: Process Models: Waterfall, Incremental, RAD and Big Bang compares the main ways to arrange these activities and shows how to choose one for a project.

