On this page
I have a habit of looking at things as complete systems.
When someone describes a feature, I tend to think about the product around it. When they describe a technical problem, I think about the architecture, the people, the information and the processes involved.
When I see a finished result, I’m often thinking about how all the parts came together.
I’ve found a rather simple way of explaining this.
When I look at a cake, I see the ingredients.
I see the recipe, the proportions, the preparation, the temperature, the timing and the decisions that made the finished cake possible.
Other people may simply see a delicious slice.
And naturally enough, having enjoyed that slice, they may decide they’d like another.
There’s nothing wrong with enjoying cake. The interesting question is whether we understand what it takes to make one.
The difference between a slice and a cake
A slice of cake can tell you quite a lot.
You can see its colour and texture. You can taste it. You can decide whether you like it.
But it tells you relatively little about the process that produced it.
You don’t necessarily know which ingredients were chosen, which alternatives were rejected or what would happen if the proportions changed.
You don’t know whether the cake would hold together if it were made twice as large.
And you don’t know what was learned from the cakes that didn’t turn out quite as intended.
Software is rather similar.
A working feature can be useful, impressive and entirely appropriate.
What a slice cannot show
But looking at a feature doesn’t necessarily reveal the requirements, architectural decisions, constraints or dependencies behind it.
Nor does it reveal what might happen when another feature is added.
Just one more slice
This is where the analogy becomes especially relevant to software development.
It’s perfectly natural for someone to ask for another feature.
They liked the first one. It works. Why not have something else?
But a feature rarely exists entirely on its own.
What appears to be a small addition may affect information structures, permissions, interfaces, business rules, security, performance or the way the product is maintained.
Sometimes the change is straightforward.
Sometimes it requires reconsidering decisions made much earlier.
If we keep concentrating exclusively on the next slice, we may eventually discover that the cake no longer holds together.
At that point, the problem isn’t necessarily the latest request.
It’s that nobody has been looking carefully enough at the whole.
The cake without sugar
Now imagine baking a cake and forgetting the sugar.
You carefully prepare the mixture, put it in the oven, wait for it to bake and take it out.
It looks like a cake. It has the right shape. You can cut it into slices. You might even decorate it beautifully.
But something fundamental is missing.
Sugar isn’t simply something that makes a cake taste sweet. It contributes to the texture, structure, moisture and way the ingredients behave together during baking.
You can sprinkle sugar on top afterwards. You can add icing. You might even disguise the problem well enough that someone takes a second bite.
The missing ingredient
But you cannot go back and incorporate the missing sugar into the original mixture. That opportunity has passed.
If you want the cake you originally intended to make, you may have to start again.
I’ve encountered the software engineering equivalent of this problem throughout my career.
A system can look complete, demonstrate impressive functionality and appear to satisfy its immediate requirements while lacking something fundamental in its underlying design.
Perhaps an essential operational requirement was never considered. Perhaps the information architecture cannot support the relationships the product needs. Perhaps an early architectural decision makes a critical future capability impractical.
These aren’t necessarily problems that can be solved by adding another feature.
Some omissions can be corrected relatively easily. Others affect so many connected decisions that repairing the original implementation becomes more difficult and expensive than rebuilding the affected foundations.
And the longer development continues, the more costly that discovery can become.
This is why I place such importance on understanding the ingredients before committing to the recipe.
It doesn’t mean every possible requirement must be known in advance. That would rarely be realistic.
It means recognising which decisions are fundamental, investigating the consequences of getting them wrong and validating important assumptions while there is still an opportunity to change direction.
You can add another slice to the plate. You cannot always add a missing ingredient to a cake that’s already been baked.
Why I think about ingredients
My approach has developed through many years of designing, building and maintaining software.
I’ve learned to consider how apparently separate decisions influence one another.
The user experience is related to the information architecture. The information architecture is related to the data model. The data model influences the application architecture. Security, accessibility, performance and maintainability affect all of them.
These relationships matter whether a system is large or small.
When I begin examining a problem, I’m not trying to make it unnecessarily complicated.
I’m trying to understand enough of its underlying structure to make the eventual solution as straightforward as possible.
Sometimes that leads to a different architecture.
Sometimes it leads to a simpler interface.
And sometimes it leads to the conclusion that the requested feature isn’t actually necessary.
That last outcome can be particularly valuable.
You don’t need to bake every cake yourself
Seeing the whole system doesn’t mean possessing every specialist skill or making every decision alone.
A good product may depend on the experience of designers, developers, domain specialists, security professionals, operational teams and the people who will ultimately use it.
Each brings something important.
The challenge is ensuring those contributions remain connected.
Someone needs to understand how the ingredients work together, what the finished product is intended to achieve and what happens when one part changes.
I think of that as part of systems architecture and product design.
It’s not about being more important than the specialists involved.
It’s about maintaining the relationships between their contributions.
Design-led development is understanding the recipe
This is one reason I place such importance on design-led development.
Design helps establish the intended outcome and the relationships needed to achieve it.
It is where we consider what belongs, what doesn’t, how the components interact and which decisions have the greatest consequences.
The Software Development Lifecycle then provides the discipline for carrying that intention through implementation, testing, deployment and ongoing development.
Neither is about creating bureaucracy.
Both are about understanding what we’re making and retaining responsibility for how it turns out.
A new kind of kitchen
AI-assisted development has made this analogy even more interesting.
Today, tools such as GPT can contribute significantly to implementation. Work that once required considerable specialist effort can often be explored and produced much more readily.
I see enormous possibilities in that.
But greater production capability does not automatically produce a better recipe.
Someone still needs to know what we’re trying to make, why the ingredients belong together, what constitutes an acceptable result and whether the finished product actually meets its purpose.
That is where experience, curiosity, design and engineering judgement remain essential.
The pleasure of making something work
I don’t want this analogy to suggest that everyone should become a systems architect.
There is real value in people concentrating on what they know and do well.
Nor do I think every project requires a complete architectural investigation before anything useful can happen.
Sometimes a small experiment is exactly the right next step.
What matters is understanding how that experiment fits into the larger intention and what we can reasonably conclude from it.
Personally, I find considerable satisfaction in making complex things work simply.
I like understanding the ingredients, choosing an appropriate approach and seeing the result come together.
And I particularly enjoy it when the person using the finished system doesn’t need to think about any of that.
They can simply get on with what they came to do.
Perhaps that is the best outcome of good design and engineering.
The person using the system gets to enjoy the cake. The responsibility of the engineer is to understand how it was made, why it works and whether the next slice will be just as good.
Research context
Topic: Design-led development
Explore further
Further reading is listed below.