We are an independent publication. We verify assertions against the documents that make them, cite our sources in the sentence where they do the work, and correct the page when we make a mistake. The publication has the byline because the logic is ours.
What software development produces
IBM defines software development as a set of computer science activities dedicated to creating, designing, deploying and supporting software, with the goal of a product that meets user needs and business objectives in an efficient, repeatable and secure way. The wording is worth keeping because it contains the need, the build and the running of the system in one frame. Teams that separate them pay for it later.
What a team ships is not source code. Source code is the material. What ships is behaviour: what the system does when a user is impatient, when a dependency is slow, when a record arrives with a field missing. Code that has never met those conditions is a proposal.
The lifecycle ends where the user starts
IBM sets out the software development life cycle as planning, analysis, design, implementation, testing, deployment and maintenance, and notes that the steps may run in sequence or in parallel depending on the model a team uses. The useful point is not the list. Maintenance keeps producing requirements, so the cycle continues. A team that treats deployment as the finish line meets its users for the first time during an incident.
IBM also places DevOps, continuous integration and continuous delivery at the centre of current practice, with automation used to deploy small, frequent updates. Small updates are not a matter of taste. They are how a team keeps the cost of making mistakes low enough to keep learning.
Selecting a model involves deciding where you expect errors to occur
IBM catalogues the common software development models: waterfall, V-shaped, iterative, agile, DevOps, rapid application development, spiral, lean and big bang. IBM provides the model titles, and we treat each one as an assumption.
| Model | Assumption | Where it fails |
|---|---|---|
| Waterfall | requirements can be settled before building starts | a discovery late in the build invalidates earlier work |
| Iterative | each pass teaches the team enough to plan the next | feedback arrives after the decision it should have changed |
| Agile | priorities will change, and should change | the change has no owner, so it arrives as scope creep |
| DevOps | delivery and operations share one outcome | automation outruns the team's understanding of what it runs |
| Spiral | risk can be retired one loop at a time | the loops carry on without closing |
The team must ask what they will do when the central assumption of any model proves to be false.
Standards are an organisation's memory of its own mistakes
The GOV.UK guidance on government technology standards collects the criteria public bodies use to design, build and buy technology. It covers open source by default, API standards, the Service Standard, accessibility and the security guidance that accompanies them. A developer outside government finds value in its structure: a set of criteria for checking a project.
The Defra software development standards state that they apply to all software development undertaken on behalf of the Defra group, whether by staff, contingent workers or suppliers. The repository is maintained in markdown under source control so that anyone can propose a change through a pull request. The obligation is put plainly:
All developers working on behalf of Defra need to be aware of their obligation to follow these standards. Any deviation must be managed as an exception under Defra's architectural governance processes.
That is the whole case for standards. A standard is a standard only when departing from it needs a named decision from someone with authority. Otherwise it is advice, and advice loses to the deadline every time.
Formal standards bodies cover the same ground. Orient Software's survey of software development standards sets out the ISO, IEEE and IEC families that apply to software engineering. Its summary of the scopes is the clearest short account we have found:
- Quality management: guidance for applying a quality management system to software.
- Life cycle: one standard for software processes, another for systems that contain software.
- Measurement: how a team defines, collects and uses software measurement.
- Testing: test processes, documentation, techniques and keyword-driven testing.
- AI management: governance, transparency and accountability for AI systems.
Risk is a property of the plan, not a phase of the project
Square Root's guide to software development risks draws a distinction that most project documents blur: a risk has not happened yet, while an issue already exists. A third-party API that may become unavailable is a risk. The same API, unavailable and blocking transactions, is an issue.
It reports a change-impact review on a logistics project where a client added a multi-stage approval workflow after development had started. The review traced the change through database relationships, user permissions, notification logic and regression testing before implementation, and the release plan changed as a result. It also reports a transport platform where a carrier API did not return the real-time status events the tracking screen assumed, and the fix was retry handling with scheduled reconciliation.
That second example is the pattern to copy. A risk entry earns its place when it specifies the dependency, the failure and the consequence in one line. Third-party dependency is not a risk; it is a category. The carrier API does not return real-time events, so the tracking screen shows stale shipments, is a risk, and it points at what to build: a retry, a queue, a reconciliation job, or an honest label on the screen.
Ship changes you can take back
OpsLevel's account of software development standards and practices includes feature flags and small deploys among the practices that reduce risk, because a feature enabled for a subset of users can be watched before it reaches everyone, and a small deploy can be reversed without unpicking a release.
A canary release applies the same logic to a change in code or infrastructure. A slice of traffic goes to the new version, a gate compares what that slice is doing with what the stable version is doing, and the pipeline either promotes or rolls back. The commands below are placeholders; the format is the part worth copying.
# Run after the canary has taken live traffic for a full observation window.
canary_errors=$(read_metric canary error_rate)
stable_errors=$(read_metric stable error_rate)
if [ "$canary_errors" -gt "$stable_errors" ]; then
rollback_canary
exit 1
fi
promote_canary
Two properties make this work. The comparison is against the system as it is running now. The rollback process is written before the change goes out, so that a developer does not have to create one under pressure.
The roles divide the work; the work does not divide itself
Lancashire's guide to becoming a software developer shows the roles the work is divided into: frontend, backend, full stack, UI and UX design, software testing, web development, mobile development and embedded systems. The division is real, and it is also a hiring convenience.
The work crosses the boundaries constantly. A frontend developer who cannot read a server response will guess at what the error means. A backend developer who never looks at the interface will design errors that no user can act on. A tester in the design conversation will verify what was needed. Learn the role you are paid for, then learn the edge of it.
Learning the craft without pretending there is a shortcut
Lancashire advises starting with fundamentals, practising on small projects, learning the tools and improving problem solving. Python or Java are reasonable first languages, and Git, GitHub and an editor are the tools to become fluent in. A degree is one way to enter the field, alongside certifications, bootcamps and a year in industry.
We would add a practice the guides tend to leave out. Build something one other user employs, and keep it running for long enough that they notice when it breaks. The feedback loop teaches more than another tutorial, because it forces the questions that matter: You can learn what happens when the data is incorrect, whom to notify when it fails, and how to modify it without breaking existing functionality.
How we check what we publish
Every statement on this page that specifies a document is linked to that document in the sentence where it is used. Where we describe practice, we say whether it comes from a published standard, a supplier's account or our own reading. Where we compare approaches, as in the table above, we mark the analysis as ours.
If you find an error, tell us. We correct the page and record the correction. Software development rewards people who can hold a system in their head and still ask what they have missed. That is the subject we cover, and this page is where we start.
Sources
- Government technology standards and guidance
- Software development standards (Defra)
- What is software development?
- Software Development Risks: Types & Mitigation Strategies
- Standards in software development and 9 best practices
- Becoming a Software Developer
- What Software Development Standards Should You Be Aware Of?
























