01 / The starting point
An idea is not a plan. And that is perfectly fine.
Most digital work starts with something that is not quite formed. It might be a new service, an internal system, a product someone has been thinking about for months or a small improvement that has somehow become everybody’s problem.
Usually, there is a good reason behind the idea. But the moment we start discussing how to build it, things can get complicated remarkably quickly. Someone wants a dashboard. Someone else wants an app. Before long, we are having a very serious conversation about technology, and we have not quite agreed on the problem.
After years working across development, user experience and digital delivery, I have come to appreciate that getting started is rarely the hard part. The harder part is turning an uncertain idea into a series of sensible decisions without losing sight of the people the work is meant to help.
For me, that means connecting product thinking, UX, technology and delivery from the beginning. Not as separate stages that occasionally send one another a document, but as different perspectives on the same problem.
02 / Problem before features
The feature list can have its turn. Just not yet.
When someone says, “We need a new portal,” I am interested in what has led them to that conclusion. What are people trying to do? Where does it become confusing, slow or frustrating? Who is doing the work behind the scenes? And what would a genuinely better outcome look like?
Those questions are less exciting than choosing a technology stack. They are also much less expensive than building the wrong thing.
I like to make a few basics visible early: who is affected, what they need to achieve, which constraints are real, what we already know and what we are still assuming. Then we can ask what the smallest meaningful improvement might be.
Sometimes the answer really is a new product. Sometimes it is a clearer form, better information, a simpler hand-off or a change to a service that already exists. I would rather discover that before we have spent three months designing a very polished solution to the wrong problem.
03 / Connected decisions
A good interface cannot rescue a confused service.
I have always enjoyed the space where user experience and development meet. You can have an elegant interface with wonderful typography, but if the underlying process makes no sense, people will still struggle. Equally, a technically impressive system may be of little use if nobody understands how to complete the task it was built for.
That is why I think the conversation needs to include content, information architecture, accessibility, technical constraints and the realities of delivery. Not everything needs to be solved at once, but important decisions should inform one another.
Working on digital services, including in the public-sector environment here in Canberra, has reinforced how much continuity and clarity matter. The person using a service, the person supporting it and the person maintaining it six months later may have very different needs. A useful product has to consider more than the moment someone presses the main button.
And when a trade-off is necessary, let us make it visible. Explain what we gain, what we give up and why we have made that choice. Future teams should not need to conduct an archaeological dig through old meeting notes to understand a decision.
04 / Turn uncertainty into learning
Separate what we know from what we hope is true.
It is tempting to make an early idea sound more certain than it is. We have all seen a beautifully formatted project plan that makes unknowns look suspiciously like confirmed facts.
I prefer to be clear about the difference. A fact might be an existing technical limitation, a documented policy or a process we have observed. An assumption might be that users understand a particular label, that a proposed integration will work or that an extra approval step is really needed.
Once those are written down, we can decide what needs investigating instead of debating opinions indefinitely.
That is where small experiments become useful. A conversation with the right people, a rough sketch, a clickable prototype, a revised journey or a limited technical test can answer one meaningful question without committing the team to an entire solution.
The experiment does not have to look impressive. It has to teach us something. If it confirms the direction, great. If it shows we were wrong, even better to find out before building everything around that assumption.
05 / Understandable delivery
A delivery plan should help us decide, not just look busy.
Once a direction starts to emerge, I want the team to have a shared picture of what happens next. What are we exploring? What has been agreed? What evidence are we waiting for? Who needs to make the next decision? What can we reasonably deliver first?
Milestones, budgets and dependencies matter. Of course they do. But a plan becomes far more useful when it explains the decisions behind the activities rather than simply presenting a long list of things to tick off.
It also helps to know who owns each decision, who needs to contribute and who will eventually live with the outcome. Small notes alongside the work can save an enormous amount of time later. Particularly when the person who remembers why something was done has moved on to another project, gone on leave or, quite understandably, forgotten.
I do not think every unknown needs to be resolved before work begins. We just need to know what is uncertain, what we intend to learn next and how we will respond when that learning changes the plan.
06 / After go-live
The launch is a milestone. It is not the finish line.
There is a moment in digital delivery when everyone celebrates going live. And we should. A lot of work goes into getting something into the hands of the people who need it.
But the product does not stop existing when the project team closes its final task. Content will need updating. Requirements will change. Something will break. Someone will need to understand a decision that made perfect sense at the time but now looks a little mysterious.
That is why maintainability deserves a place at the table from the beginning. Familiar patterns, sensible naming, clear ownership, manageable dependencies and documentation of the important decisions can make a real difference. So can thinking early about accessibility, security, data and operational support.
Simple does not mean simplistic. It means resisting complexity that does not earn its place. If we build a clever system that only its original developer can understand, we have probably left someone an expensive little puzzle.
I would like the next team to inherit something they can confidently improve, not a collection of mysteries and a polite note wishing them luck.
07 / What useful means
Build something people can actually live with.
For me, good digital work is a combination of curiosity and discipline. Understand the problem before prescribing a solution. Include the people who know the work. Test assumptions while they are still cheap to change. Make decisions understandable and build with the people who will eventually support the result in mind.
It does not mean producing an enormous strategy document or slowing every decision down. Often the most useful next step is surprisingly small. But it is a step taken with purpose, rather than one taken because a feature list happened to be ready.
I enjoy the part of the work where an unclear idea gradually becomes something that people can explain, use and improve. That is where product thinking, UX, technology and delivery start to feel like one conversation.
The goal is not just to get something built. It is to make something useful today, clear enough to understand tomorrow and maintainable enough to keep making better.