Digital projects rarely fail on technology.
They fail on goals nobody wrote down, clarification that got skipped, and an acceptance test nobody agreed on. We work in four phases : Discover, Design, Deliver, Improve. Each one ends with a result you own and can use, with us, with another supplier, or on your own.
Available as a single phase or as the full path
Why a structured path
The cheapest place to change your mind is at the beginning.
Late changes are the expensive ones
Changing a sentence in Discover costs a conversation. Changing the same thing after Deliver costs a rebuild, a re-test and a release. The first two phases exist to move decisions earlier, while they are still cheap.
Every phase ends in something you keep
An agreed problem statement. A specification with acceptance criteria. Running software with its source and documentation. A measured effect. Each one is usable on its own, and none of them needs us to stay valuable.
“Done” is written down before the build starts
Most late disputes are really about acceptance : two people meant different things by the same word. Acceptance criteria are written in Design, in your language, and tested in Deliver against exactly that wording.
You can stop after any phase
Discover is allowed to end in “do not build this”. We would rather reach that answer in week two than in month six, and so would whoever holds the budget.
The four phases
3D-I : Discover, Design, Deliver, Improve.
The same path whether the result is an app, a portal, an AI service or a change to how a team works. What varies is how long each phase takes and how much of it you already have. The first two happen mostly in a room with your people, not in a document sent back and forth.
Phase 01
Discover : decide what is worth doing
Before anything is built we establish what problem is being solved, who actually has it, what it costs today and what a fix is worth. Short and time-boxed. Runs as a discovery sprint, an AI opportunity assessment, a customer journey review or an accessibility assessment, depending on the question you arrive with.
- A written problem statement everyone in the room signs up to
- The candidate solutions, ranked by effort against value
- A go or no-go you can defend to whoever holds the budget
Phase 02
Design : make it buildable
We turn the decision into something a team can build against : what the system has to do, how a person moves through it, how the pieces fit together, and what must be true before anyone calls it finished. Requirements analysis, UX concept, solution architecture, and a prototype your users can click before the thing exists.
- Requirements with acceptance criteria, so “done” is testable
- A clickable prototype real users can react to
- An architecture another supplier could build from
Phase 03
Deliver : build it and put it in production
Apps, portals, AI solutions and accessibility work, built against the criteria agreed in Design and tested against exactly those. You see working software at short intervals rather than one reveal at the end, so a wrong turn costs a week instead of a quarter.
- Working software in production, not a demo environment
- Tested against the acceptance criteria you approved
- Source and handover documentation, so you are not tied to us
- Accessibility built in rather than retrofitted under pressure
Phase 04
Improve : measure it, then make it better
Once it runs the question changes : is it doing what we said it would? We measure the effect, find where the process still hurts and change it. Runs as a workflow optimisation sprint, a process effectiveness review, or an AI governance check where a system makes decisions about people or money.
- A measured before and after, not an opinion
- A prioritised list of changes with the effort each one takes
- For AI : what the system may decide alone, and who is accountable when it does
Where the programme lives
The phases need somewhere to happen.
A method is only as good as the record it leaves behind. The portal is where an engagement is actually run: what was scoped, what was decided, what has been delivered, and what it turned out to be worth.
Shortening the path
If you already have the clarity, we skip the phase that produces it.
Nobody should pay twice for the same certainty. Bring what you have and we start where it stops.
You know the problem : start at Design
The problem statement and the case for doing something already exist and are agreed inside your organisation.
- We read what you have before we quote
- We say plainly if we think something is missing
- Discover shrinks to a half-day review
You have a specification : start at Deliver
Requirements and acceptance criteria are written. We build against them and we test against them.
- Short review of the criteria before we commit
- Fixed scope per increment, visible progress
- Your specification stays the reference, not ours
It runs but it does not pay off : start at Improve
For systems already in production, whether we built them or somebody else did.
- Where the process actually loses time
- What can be automated and what should not be
- Governance check for anything with AI in the loop
3Di+ : the same four phases, applied to automation
When the subject is an automation rather than an application, the phases stay and the artefacts change : each phase leaves its record in the platform instead of in a document nobody opens again. Discover finds the candidate processes and puts a value on each one. Design makes the chosen process implementable, with the inputs, the rules and the exceptions named. Develop builds the automation together with the tests that prove it. Improve measures what it saved and keeps watching itself, so drift in the underlying process shows up as an alert rather than as a surprise at the quarter end.
Autonomy
You decide how much the automation is allowed to decide.
Three levels, chosen per process and changed as trust grows. Nothing moves up a level without you asking for it.
Fixed rules
The automation does exactly what was specified. Same input, same output, every time, and the reasoning stays readable by a person.
- Best where the process is stable
- Best where a wrong call is expensive
- Fully reproducible for an auditor
Proposes, a person approves
The agent prepares the decision and a named person releases it. The gathering and drafting disappear ; the judgement stays with a human.
- The usual starting point
- Right for anything with money or a customer at the end of it
- Every approval recorded with who and when
Decides inside guardrails
The agent acts on its own within limits you set : which systems it may touch, which value ranges it may act in, which exceptions it has to escalate.
- The limits are configuration, not code
- Everything it did stays visible and reversible
- Out-of-range cases go back to a person automatically
Who brings what
The phases only work if both sides show up.
A discovery sprint with nobody from the shop floor in the room produces a nice document and the wrong project. The people who do the work today are the ones who know where it hurts.
What you bring
Someone who owns the problem and is allowed to decide. Access to the people who do the work today. The numbers you already have, however rough. A few hours a week during Discover and Design, less during Deliver.
What we bring
Facilitation, analysis, design and the build itself. A written result at the end of every phase, handed over whether or not you continue with us. And the plain answer when a phase says stop, which is the part most suppliers leave out.
How to start
Three ways in, in rising order of commitment.
Lowest commitment
A call
Thirty minutes. You describe the situation, we say whether we think there is a project in it and which phase you should actually start at. If the answer is “you do not need us for this”, you get that too.
Half a day
A workshop
With the people who have the problem, not only the people who own the budget. You leave with the problem written down, the options on the table, and a shared view of what is worth investigating further.
A short engagement
A discovery sprint
The full first phase, time-boxed. It ends with the agreed problem statement, the ranked options and a go or no-go. Whatever you decide afterwards, that result is yours to use.
This is how every SYN IT engagement runs
The delivery model is not separate from the products. A KPI cockpit, an AI assistant or a shop-floor system all arrive through the same four phases, which is why a Discover phase can end with “buy this product” instead of “build something new”. Where an automation comes out of it, Agent Manager runs it and records what it did.