Software Engineering UKSoftware Engineering UK
Software Development
Software Engineering UK

Software Development

Software development is the work of turning a described need into a running system, then keeping that system correct as the need changes. The phrase covers design, code, tests, deployment, documentation and the arguments that settle what the software should do. This page is our guide to the subject. It is written for readers who came to learn the work.

Browse guides

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:

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

The full list

AI-Driven Code: How to Ensure System Reliability
AI-Driven Code: How to Ensure System Reliability

Engineers must retain full accountability for AI-assisted code because models cannot know system-specific failure modes.

Platform Engineering for LLM Applications
Platform Engineering for LLM Applications

Platform engineering creates a shared layer to manage the identity, budget and audit trails of LLM applications.

Software Factory: Build Your Delivery Pipeline
Software Factory: Build Your Delivery Pipeline

The software factory architecture manages the increase in agent-led code production by focusing on the delivery system.

CI/CD Pipelines That Earn Their Place
CI/CD Pipelines That Earn Their Place

Merge gates, promotion lines, and canary releases provide three distinct points to stop unsafe changes from reaching users.

Will AI agents replace the daily sprint?
Will AI agents replace the daily sprint?

AI agents can automate pull request merges, reducing the technical necessity of the two-week sprint box.

Getting Started With DevOps Practices
Getting Started With DevOps Practices

DORA data shows organisations with formal external approval processes are 2.6 times more likely to be low performers.

DevSecOps: What Good Looks Like
DevSecOps: What Good Looks Like

A DevSecOps programme is only effective if no team can bypass the recorded security decisions of the pipeline.

Making Digital Transformation Work
Making Digital Transformation Work

Digital transformation succeeds when it changes specific organisational decisions and the speed at which they are made.

Full Stack Development, Explained
Full Stack Development, Explained

AWS defines full stack development as the process of developing both the frontend and the backend of an application.

Microservices Architecture: What to Look For
Microservices Architecture: What to Look For

Microservices architecture provides independent deployment and scaling by dividing a system into autonomous services.

When Low-code Platforms Are Worth It
When Low-code Platforms Are Worth It

Low-code platforms only provide value when process rules outweigh interface needs and strict guardrails are in place.

Software Development Agencies London
Software Development Agencies London

Verify software development agencies London using tests based on the Copyright, Designs and Patents Act 1988.

Choosing Software Development Methodologies
Choosing Software Development Methodologies

Choosing a software development methodology should be based on failure modes rather than labels.

Software Engineering: The Case for and Against
Software Engineering: The Case for and Against

Software engineering differs from programming by making checkable claims about a system before it exists.

Breaking the AI Hardware Monopoly
Breaking the AI Hardware Monopoly

DeepSeek and Huawei are releasing open-source programming tools for Ascend chips to lower the barrier for developers.

Predicting the Future with Zero-Shot Models
Predicting the Future with Zero-Shot Models

Zero-shot forecasting models provide a superior alternative to traditional tuning by prioritising reuse over maintenance.

How to Vet a Development Partner's Logic
How to Vet a Development Partner's Logic

Vetting a development partner involves assessing the reasoning process rather than just the initial proposal.

Stop Tracking LoC: Better AI Dev Metrics
Stop Tracking LoC: Better AI Dev Metrics

Measuring AI productivity through volume alone ignores the costs of rework and review queues.

AI agents and the new rules of governance
AI agents and the new rules of governance

Governance for AI agents must move from static documents to integrated controls within the delivery pipeline.

Software Craftsmanship in the Age of AI
Software Craftsmanship in the Age of AI

Software craftsmanship treats development as a skilled trade based on technical mastery and ethical responsibility.

Is your code quality actually dropping?
Is your code quality actually dropping?

Verification capacity has failed to keep pace with the surge in code generation capacity provided by AI coding agents.

PHP 8.6: A Quick Guide to the Best Upgrades
PHP 8.6: A Quick Guide to the Best Upgrades

PHP 8.6 introduces partial function application and a new Duration class to reduce boilerplate and improve precision.

How should Dev and QA align in the AI era?
How should Dev and QA align in the AI era?

Software delivery constraints have shifted from the act of writing code to the process of proving that code is safe to release.

Why this site

Checked by a person

The pages stay on software development, and none is published until a person has checked it.

Specific

Numbers, steps and named tools rather than principles.

Always current

Refreshed when a page falls out of step with what is now known.

Traceable

Where a number comes from is on the page: 119 publishers cited.

Begin with these

How should Dev and QA align in the AI era?

Software delivery constraints have shifted from the act of writing code to the process of proving that code is safe to release.

AI-Driven Code: How to Ensure System Reliability

Engineers must retain full accountability for AI-assisted code because models cannot know system-specific failure modes.

Platform Engineering for LLM Applications

Platform engineering creates a shared layer to manage the identity, budget and audit trails of LLM applications.

The questions behind the guides

What are the best practices for LLM prompt changes?

Changes should use example-based tests on structured fields, property tests scored by evaluator models, and adversarial cases from previous failures.

Platform Engineering for LLM Applications
What is the velocity trap in software delivery?

It occurs when agents increase code output but review queues and deployment cycles remain unchanged. This leads to a stack of pull requests waiting for the same human reviewers.

Software Factory: Build Your Delivery Pipeline
How should teams decide where to invest in the pipeline?

Teams should timestamp changes from the first commit to the production release. Investment should be directed toward the station with the longest wait time.

Software Factory: Build Your Delivery Pipeline
How does blast radius affect the review process?

Changes are categorised by their potential risk. Low-risk updates merge automatically on green, while high-risk changes, like authorisation, require human sign-off.

Software Factory: Build Your Delivery Pipeline