Chapter 1 · How Software Gets Built
What Software Engineering Is, and Why Coding Is Not Enough
- Page 1 of 18
- 18 min read
You can write a little Python. You can make a script that reads a file, adds some numbers and prints a result. That is programming, and it is a real skill. But the software that clinics, banks, schools and shops rely on every day is not one script written by one person on one evening. It is built by a team, used by people the team never meets, and changed again and again for years. Doing that well needs more than code. It needs a way of working, and that way of working is called software engineering.
This first page explains what software engineering adds to programming, where the name comes from, and why it matters even for a small project or a solo freelancer. It also introduces ClinicQueue, the invented project that you will follow through the whole tutorial, and the people who build it.
What you will learn
- How writing a program that works once differs from building software that a team can change safely for years.
- Where the term "software engineering" became well known, and what the classic IEEE definition means in plain words.
- Why a disciplined way of working matters: late changes, many users and real customers.
- What a software engineer actually does in a normal week, from understanding the problem to maintaining a release.
- The ClinicQueue running case, its team, and the difference between "it works on my laptop" and a product.
How to use this tutorial
There are 18 pages in five chapters. Read them in order the first time, because each page builds on the one before. Later you can come back to any page on its own.
| Chapter | Pages | What it covers |
|---|---|---|
| How Software Gets Built | 1-4 | What software engineering is, the software development life cycle, process models such as Waterfall and incremental, and Agile, Scrum and Kanban. |
| Requirements | 5-7 | Finding out what to build, functional and non-functional requirements, acceptance criteria, user stories and priorities. |
| Planning and Risk | 8-10 | Project management and team roles, estimation and scheduling, and risk management. |
| Design and Code | 11-14 | Design from requirements to modules, entity-relationship diagrams, maintainable code, code review and team workflow. |
| Quality, Release and the Future | 15-18 | Testing and quality assurance, release and maintenance, working with AI coding assistants, and a practice lab with a capstone. |
One running case. Almost every page uses the same invented project, ClinicQueue, so you see one product grow from an idea to a release. You will meet it below. Some pages add a short side case when a contrast helps, and it is always labelled. Every project, person and number in this tutorial is invented unless the page names a real source.
Exercises. Each page ends with "Try it yourself": three tasks marked Easy, Medium and Hard, followed by worked answers. Try the task before you read the answer. For open tasks, the answer gives a model answer and the points a good answer must contain, so you can check your own.
Code. Most pages use tables, short templates and worked examples, not code. Pages 9, 10, 13, 15, 16 and 18 include small Python examples. For those you need Python 3.12 and nothing else: the examples use only the standard library, need no network, no account and no paid software. If you can write a function and a loop, you know enough Python. If not, Python for AI: From Zero to Your First AI App covers it.
Videos. Beside most pages you will find video lessons. Most are recent Bangla lectures (2025 or later) from teachers' YouTube channels; a few are in English where no recent Bangla video fits the topic. The videos are optional support. They are a good second explanation, but the page is the complete lesson, and no exam question depends on a video.
Exams. There are three exams. Quiz 1 (Easy) comes after chapter 2 and covers pages 1-7. Quiz 2 (Medium) comes after chapter 3 and covers pages 1-10. The Final Exam (Hard) comes after chapter 5 and covers the whole tutorial. Most questions describe a short situation from a project and ask what a careful engineer would do.
Programming and software engineering
Programming is writing instructions that a computer runs. Software engineering is building and looking after software so that it keeps meeting real needs while time passes, people change and requirements change. A short way to remember the difference: programming is about making it work; software engineering is about making it work for the right people, and keeping it working when everything around it changes.
Three things turn a program into an engineering problem.
- Time. A script you run once can be messy. Software that runs for five years will be read and changed many times, often by someone who did not write it, maybe by you after you have forgotten how it works.
- People. When several developers work on the same code, they need shared agreements: what to build next, how code is reviewed, how a change reaches users. When customers and users are involved, someone must find out what they really need.
- Change. Requirements change, laws change, phones and browsers change, and bugs are found. Software that cannot be changed safely becomes expensive and risky to keep.
| Question | A program that works once | Software a team changes for years |
|---|---|---|
| Who uses it? | The author | Customers and users the team may never meet |
| Who changes it? | The author, today | Many people, over years |
| How do we know it works? | "I ran it and it looked right" | Agreed acceptance criteria and repeatable tests |
| What happens when it fails? | Run it again | Real people are affected; someone must find and fix the cause |
| What is written down? | Nothing, or a comment | Requirements, a plan, design notes, a change history |
| How is it delivered? | Copied to one computer | Released in versions, installed and supported |
None of this means programming matters less. Good code is at the centre of software engineering; a whole page, Writing Maintainable Code, is about it. Software engineering puts the code inside a process that helps a team decide what to build, check that it is right, and change it safely.
A useful test for any project: if the person who wrote it disappeared tomorrow, could someone else understand it, fix a bug in it and release the fix? If the honest answer is no, the project needs more engineering, not more code.
Where the name and the definition come from
The 1968 NATO conference
In October 1968 the NATO Science Committee sponsored a conference on software engineering in Garmisch, Germany (7 to 11 October 1968). Its report was edited by Peter Naur and Brian Randell and is dated January 1969. The conference did not invent the phrase, but it made the term "software engineering" well known. The report explains why the name was picked:
"The phrase 'software engineering' was deliberately chosen as being provocative, in implying the need for software manufacture to be based on the types of theoretical foundations and practical disciplines, that are traditional in the established branches of engineering."
In plain words: the organisers wanted to push software builders to work more like engineers who build bridges or power systems, with planning, known methods and checks, instead of relying on talent and luck.
A classic definition
The classic IEEE definition (IEEE 610.12, 1990) says software engineering is:
"(1) The application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is, the application of engineering to software. (2) The study of approaches as in (1)."
Take it word by word, using ClinicQueue as the example.
| Word in the definition | Plain meaning | In ClinicQueue |
|---|---|---|
| Systematic | Work follows known steps, not whatever comes to mind | The team writes down requirements before designing the booking screen |
| Disciplined | The team keeps its agreements even when in a hurry | Every change is reviewed and tested, also on a busy Friday |
| Quantifiable | Things are measured, so progress and quality can be checked | "A booking page opens within 3 seconds on a slow phone connection" |
| Development | Building the software | Writing the booking, reminder and queue features |
| Operation | Running it for real users | Keeping ClinicQueue online during clinic hours |
| Maintenance | Changing it after release | Fixing bugs and adding the AI reminder draft later |
Notice that the definition covers operation and maintenance, not only development. Software engineering does not stop on release day. Today the field also has a shared vocabulary standard, ISO/IEC/IEEE 24765:2017 (Systems and software engineering — Vocabulary), where terms like this one are defined.
Why it matters
Late changes cost more
A misunderstanding found while talking to the customer costs a conversation. The same misunderstanding found after the software is built costs redesign, new code, new tests and perhaps unhappy users. Testing experts state this as a principle: "Early testing saves time and money" (one of the seven testing principles in the ISTQB Foundation Level syllabus). You will hear large numbers quoted for how much more a late fix costs; those figures are not reliable, so this tutorial does not use them. The direction is what matters: the earlier you find a problem, the cheaper it usually is to fix.
Many people rely on it
A script that fails annoys its author. Software that fails can stop a clinic from seeing patients, send a reminder to the wrong person, or expose private data. The more people depend on software, the more care its builders owe them: testing, review, careful releases and a way to fix problems quickly.
Customers are part of the work
Most software is built for someone else. Customers often cannot say exactly what they need at the start, and they change their minds when they see a first version. Software engineering gives you ways to handle this calmly: asking good questions, writing requirements down, showing early versions, and agreeing how changes are accepted.
How much process is enough?
Practitioners disagree about how much process a project needs, and both sides have a point.
- More process: written requirements, reviews, tests and plans prevent expensive mistakes, help new people join and are needed where software is regulated or safety matters.
- Less process: every meeting and document costs time; a two-day prototype does not need a 20-page plan, and heavy process can slow learning.
A sensible rule: match the process to the risk. Ask how long the software will live, how many people will change it, and what happens if it fails. A throw-away experiment needs very little. ClinicQueue, which handles patients' bookings and phone numbers for years, needs more. You will learn to make this choice on Process Models: Waterfall, Incremental, RAD and Big Bang and Agile, Scrum and Kanban.
Meet ClinicQueue and its team
Invented scenario:
A small clinic has two doctors and one reception desk. Today patients phone to book, and the
receptionist writes the bookings in a paper diary. The phone is busy all morning, some patients
forget their appointment, and nobody knows how long the queue will be.
The clinic manager wants a web app called ClinicQueue:
1. Patients book a free slot online.
2. Patients get an SMS reminder before their visit.
3. The front desk sees the day's queue on one screen.
4. Later: an AI model drafts the reminder text, and a person checks it before it is sent.These are the people you will meet on almost every page. Keep their roles in mind; the exam questions use them too.
| Name | Role | What they care about |
|---|---|---|
| Nadia | Clinic manager, the customer who pays for ClinicQueue | Fewer phone calls, fewer missed visits, a fair price, a delivery date |
| Lena | Project lead; Scrum Master when the team uses Scrum | A realistic plan, clear priorities, a team that is not blocked |
| Farhan | Developer (backend) | Bookings stored correctly, reminders sent on time |
| Aiko | Developer (frontend) | Screens that work on cheap phones and slow connections |
| Kwame | Tester / QA | Finding problems before patients do |
| Omar | UX designer | Booking that an elderly patient can finish without help |
| Dr. Rahman, Rina, patients | Users: a doctor, the receptionist, and the people who book | A queue that is correct, quick to read and easy to use |
Notice that Nadia, the customer, is not the main user. Rina and the patients use the app every day. This difference will matter when you collect requirements in chapter 2.
"It works on my laptop" is not a product
Before the team was formed, Farhan built a first version alone in a weekend. It ran on his laptop, and the demo went well. Here is what happened when Lena asked whether it was ready for the clinic.
Invented scenario:
Farhan's weekend version What the clinic actually needs
--------------------------------------- ----------------------------------------------------
Runs on Farhan's laptop Runs on a server, reachable every day from 08:00
Bookings saved in a file on his disk Bookings stored safely, backed up, kept private
Tested by clicking through once Tested with double bookings, cancellations, holidays
One user: Farhan Many patients booking at the same time
No reminder yet SMS reminders, with a plan when sending fails
Only Farhan knows how it works Anyone on the team can fix a bug and release it
"Done" = the demo worked "Done" = agreed criteria met, reviewed, releasedThe weekend version was not wasted. It was a useful prototype that helped Nadia see what she wanted. But turning it into a product meant asking questions Farhan had skipped: Who exactly will use it? What happens when two patients book the same slot? Where does private data live? Who fixes it on a Sunday? Answering those questions is software engineering.
What a software engineer does day to day
Many beginners think a software engineer spends the whole day writing code. Code is a large part of the job, but a normal week also includes understanding problems, planning, designing, testing, reviewing other people's work, releasing and fixing what is already live. The table lists these activities with an example from ClinicQueue and the page where you will learn each one.
| Activity | What it means | ClinicQueue example | Pages |
|---|---|---|---|
| Understand the problem | Find out who needs what, and why | Omar watches Rina at the desk for a morning | 5-7 |
| Plan | Decide the order of work, estimate it, spot risks | Lena and the team estimate the booking feature | 8-10 |
| Design | Decide the parts of the system and how they talk | Farhan sketches the booking and reminder modules | 11-12 |
| Code | Write clear code that others can change | Aiko builds the booking form | 13 |
| Review | Read a teammate's change before it is merged | Farhan reviews Aiko's form and asks one question | 14 |
| Test | Check the software against what was agreed | Kwame tries to book the same slot twice | 15 |
| Release | Deliver a version to users in a controlled way | The team releases version 1.0 on a quiet afternoon | 16 |
| Maintain | Fix, adapt and improve software after release | A bug in holiday dates is fixed in version 1.0.1 | 16 |
Here is how one invented week might look for Farhan. The exact mix changes with the project and the phase, but notice how much of it is not typing new code.
Example:
Farhan, one week on ClinicQueue (invented)
Mon |## planning meeting |###### code: save bookings |# review Aiko's change
Tue |# short team sync |##### code: save bookings |## write tests
Wed |# short team sync |### call with Nadia about reminders |#### design reminder module
Thu |# short team sync |## fix bug reported by Kwame |##### code: reminders
Fri |# short team sync |### review two changes |## release notes |## help Rina test
Each # is about half an hour.Count it roughly: coding new features is 16 of the 41 half-hours, well under half the week, and even with tests and the bug fix added it is only about half. The rest is talking, planning, designing, reviewing and releasing. These activities are what this tutorial teaches.
Where this shows up at work
- Job interviews for junior developers often ask how you would handle a vague requirement, a bug in production or a disagreement in a code review, not only how to write a loop.
- Freelancers who agree the scope in writing, show early versions and test before delivery have fewer disputes with clients and fewer unpaid fixes.
- Teams building AI apps still need requirements, tests, reviews and careful releases; an AI feature adds new risks rather than removing the old ones.
- Taking over someone else's project is common. Software that was engineered, with notes, tests and a change history, can be taken over in days instead of weeks.
Common mistakes
- Thinking engineering means paperwork. It bites when a team writes long documents nobody reads and still misses the customer's real need. Fix: keep only the process that reduces a real risk, and keep documents short and used.
- Treating a working demo as a finished product. It bites on the first busy morning, when real users do things the demo never tried. Fix: before saying "done", list who uses it, what can go wrong and how you will fix it after release.
- Building what the customer asked for in the first sentence. Customers describe solutions; they need outcomes. Nadia asked for "an app", but she needs fewer phone calls and fewer missed visits. Fix: ask why, and write the need down.
- Leaving testing and review to the end. Problems found late are usually harder and more expensive to fix. Fix: check early and often, from requirements to code.
- Believing software engineering is only for big companies. A solo freelancer also forgets their own code after six months. Fix: use a light version of the same habits: a short requirements list, tests and a change history.
Try it yourself
- Easy: For each item, say whether it is mainly programming or mainly software engineering, and why: (a) writing a function that checks a phone number has 11 digits; (b) agreeing with Nadia what "a booking is confirmed" means; (c) deciding that every change needs one reviewer before release; (d) fixing a typo in a variable name in your own script.
- Medium: Explain the classic IEEE definition (IEEE 610.12, 1990) in your own words in two or three sentences, and give one ClinicQueue example for each of "systematic", "disciplined" and "quantifiable".
- Hard: Rina's cousin Tariq asks Aiko for a "quick" app for his small tailoring shop: customers leave a phone number and get an SMS when their clothes are ready. He wants it in one week. Write five questions Aiko should ask before she starts coding, and say for each one which of time, people or change it addresses. Then say how much process this project needs, and why.
Answers
- (a) Mainly programming: it is a small, well-defined piece of code. (b) Mainly software engineering: it is about understanding the customer's need and writing an agreed requirement. (c) Mainly software engineering: it is a team agreement that makes changes safer over time. (d) Mainly programming: a local code fix. A good answer notices that (a) becomes engineering as soon as you ask "which numbers are valid in which countries, and who decided?"
- Model answer: "Software engineering means building, running and changing software with a planned, careful and measurable way of working, the way engineers work in other fields. It also means studying such ways of working." Examples: systematic, the team writes requirements before designing screens; disciplined, every change is reviewed and tested even on a busy day; quantifiable, "the queue screen updates within 5 seconds of a new booking". A good answer keeps all three ideas, mentions that it covers operation and maintenance, not only development, and gives examples that could be checked.
- Model questions: (1) "Who will send the SMS, and who pays for each message?" (people, and cost over time). (2) "What happens if the SMS fails to arrive?" (change: things will go wrong in use). (3) "Who will look after the app after the first week, when something breaks?" (time). (4) "Do customers agree to their phone number being stored, and how long do you keep it?" (people). (5) "Will you want more features later, such as a second shop or payments?" (change). How much process: a light one. The app is small and has one customer, but it stores phone numbers and will be used for months, so a short written list of requirements, a few tests of the main flow, and an agreed plan for fixes are worth the time. A good answer asks about the real need, not only features, covers privacy, and matches the process to the risk instead of saying "none" or "everything".
Summary
- Programming makes a program work; software engineering makes software that a team can keep changing safely for years, for people the team may never meet.
- Time, people and change are what turn a program into an engineering problem.
- The 1968 NATO conference in Garmisch made the term well known; the classic IEEE definition (IEEE 610.12, 1990) calls it a systematic, disciplined, quantifiable approach to development, operation and maintenance.
- Finding problems early usually saves time and money; how much process you need depends on the risk.
- A software engineer understands, plans, designs, codes, reviews, tests, releases and maintains. ClinicQueue and its team will show each of these.
Next: The Software Development Life Cycle (SDLC) puts these activities in order and shows what each one produces for ClinicQueue.

