On this page
I’ve been involved in designing and developing software for more than three decades. During that time, technologies, development tools, programming languages and working practices have changed enormously.
One thing has remained remarkably consistent: successful software development requires an understanding of the whole lifecycle.
That might sound obvious. In practice, I’ve encountered surprisingly different interpretations of what software development actually involves.
It’s easy to concentrate on implementation. There are features to build, problems to solve, technologies to select and deadlines to meet. Those are all legitimate concerns.
But writing software is only one part of software engineering.
The more important question is whether the work being undertaken will produce the right outcome.
Understanding before implementing
Every meaningful software project begins with some form of intention.
Someone wants to solve a problem, improve a process, establish a capability or create something that doesn’t yet exist.
That intention may be clear, or it may be no more than a collection of ideas, assumptions and expectations.
Understanding the difference is fundamental.
Over the years, I’ve learned that some of the most valuable development work happens before a solution is chosen. It involves understanding what people are trying to achieve, questioning assumptions, recognising constraints and identifying where the real problem lies.
The question behind the request
A requested feature is not necessarily a requirement. A proposed solution is not necessarily the best response to the underlying problem.
Sometimes the most useful contribution is asking a question that changes the direction of the project before unnecessary work begins.
The lifecycle connects the decisions
The Software Development Lifecycle, or SDLC, provides a framework for maintaining continuity between intention and outcome.
Discovery informs requirements. Requirements shape design. Design establishes the architecture and expected behaviour. Implementation creates the working system. Testing establishes whether that system behaves as intended.
Deployment introduces the system into its operating environment, where maintenance, support, feedback and further development continue the lifecycle.
These activities are related, not independent.
A decision made during discovery can affect database design, security, accessibility and operational support. An architectural decision can influence the experience of every person who eventually uses the system.
When those relationships are overlooked, the consequences frequently emerge later, when changes have become more expensive.
Discipline does not require bureaucracy
I don’t regard the SDLC as an argument for rigid procedures or excessive documentation.
Nor do I regard it as a synonym for waterfall development.
An effective lifecycle can be highly iterative. Requirements may evolve as prototypes reveal new information. Design decisions can be revisited. Testing can inform architecture. Operational experience can change our understanding of the original problem.
What matters is that the responsibilities remain connected.
A prototype doesn’t need an enormous specification before someone can learn from it. But it does need a purpose, an understanding of what is being tested and a way of evaluating the result.
Documentation should serve decisions, not exist merely to demonstrate that a process has been followed.
The objective is engineering discipline without unnecessary administrative weight.
Acceptance is more than functionality
One distinction I consider particularly important is the difference between software that works and software that meets its intended purpose.
Functioning is not the same as accepted
A program can execute correctly while delivering the wrong result.
An interface can look excellent while making an important task unnecessarily difficult.
A system can pass its technical tests while failing to accommodate the realities of its operating environment.
Acceptance criteria help connect what was intended to what can actually be demonstrated.
They establish observable conditions against which the implementation can be evaluated.
This is particularly useful when a project involves several disciplines or stakeholders. Everyone needs a shared understanding of what success means.
And when the evidence shows that something isn’t right, the lifecycle provides a way to investigate, correct and verify it.
The operating system is part of the product
I have always considered deployment and operation important parts of development.
A system is not finished simply because it runs successfully on a developer’s computer.
It needs to behave reliably in its intended environment. People need appropriate access, failures need to be handled, information needs protecting and the system needs to remain maintainable.
These considerations should influence design and engineering decisions from the beginning.
A beautifully implemented feature that cannot be supported sensibly is not necessarily a good design.
Why this matters even more now
AI-assisted development has changed what is possible during implementation.
Tools such as GPT can make it substantially easier to investigate alternatives, generate code, explore designs and develop working functionality.
I regard that as a significant opportunity.
But the ability to produce software more quickly does not remove the need to understand what the software should achieve.
If anything, greater implementation capability makes it more important to establish clear intentions, sound architecture and meaningful verification.
We can now build the wrong thing much more convincingly.
Keeping the whole journey connected
The SDLC has remained useful throughout my career because it addresses something more fundamental than any particular technology or methodology.
It maintains the relationship between what we intended, what we designed, what we built and what we can demonstrate.
That relationship matters whether the outcome is a small application, a complex enterprise system or a new digital product.
Good software engineering is not simply about getting something to work. It is about understanding why it should work, for whom, under what conditions and how we know the result is right.
That is why the whole lifecycle matters.
Research context
Topic: Product engineering
Explore further
Further reading is listed below.