How we put a working build in your hands in the first week
The scoping habits and project setup that let us ship something real before most teams finish discovery.
Most software projects spend their first month in meetings. We spend ours shipping. Within seven days of kickoff, every client gets a working build they can open on their own phone or laptop, deployed to a real environment and connected to a real database.
It is not a demo and it is not a clickable mock-up. It is usually small, often one journey from start to finish, but it runs. Here is how we get there, and why it matters more than it sounds.
Why the first week matters
A working build changes the conversation. Before it exists, everyone is reasoning about a product in their heads, and every head holds a slightly different version. Once it exists, the questions get sharper: is this the right first screen? Does this step need to be here at all?
It also proves the boring parts early. Hosting, sign-in, the database, the release pipeline: if any of these is going to cause trouble, we would rather find out in week one than in week ten.
What happens before kickoff
The first week only works because the scoping call does real work. Before we start, we agree three things in writing:
- One user and one outcome. Not "users" but a named role, and the single thing they must be able to do by the end of the first week. For a lending app that might be "an applicant can submit a loan request and see its status".
- What we will not build yet. The out-of-scope list is as important as the scope. It stops the first week from quietly growing into the first month.
- Who decides. One person on your side who can answer product questions within a day. Most delays are waiting, not coding.
Day one: the boring setup, done once
On the first day we set up the foundations every project needs, so nobody has to think about them again:
- A repository in your organisation, with branch protection and code review switched on.
- An automated pipeline that tests every change and deploys the main branch to a staging environment.
- Sign-in, a database with migrations, error tracking and basic logging.
- A shared channel and a written changelog, so you always know what changed and why.
We use templates we have refined over many projects, so this takes hours, not weeks. Because the code lives in your accounts from the first commit, you own it from the first commit.
Days two to five: one thin slice, end to end
Instead of building every screen half-way, we build one journey all the way through: the screen, the API behind it, the data it stores, and the test that proves it works. Designers and engineers work on the same slice at the same time, so the design is tested against real data, not lorem ipsum.
Day seven: the first demo
At the end of the week we walk through the build together, on your device, against the staging environment. You get a link you can share with colleagues or a few friendly users, the changelog for the week, and the plan for week two.
From then on, the rhythm repeats: a release, a demo and a changelog every week. The project never goes dark, and every decision is made with the latest version in front of you.
Key takeaways
- Agree one user, one outcome and an explicit out-of-scope list before kickoff.
- Set up the repository, pipeline and environments once, on day one, in your accounts.
- Build one journey end to end rather than many screens half-way.
- Demo on a real device in week one, then keep a weekly release rhythm.
Have a project in mind?
Tell us what you want to build, improve or automate. We reply within one working day.