From messy brief to shipped product.
A tight, repeatable loop that most engagements complete in two to six weeks. You see written plans before code, working software every week, and you own everything at the end.
-
Discover WEEK 1
We sit with the people doing the work, in person or on a call. We map the tools, the data, the handoffs and the failure points, and find the one thing that would change the week if it ran itself. We also check what already exists: APIs, exports, permissions, and whatever half-built automation came before us.
You get: a written map of the current workflow, a shortlist of what to automate first, and the questions that need answering before anything is designed.
-
Design WEEK 2
Architecture, data model, integrations and the user experience, written up in plain language with diagrams. You push back on every line. This is where decisions about offline, permissions, what the AI may and may not do, and what happens when something fails get made, before they are expensive.
You get: a design document, a milestone plan, and a fixed price for the first version. The scope is locked here; changes after this point are quoted separately so there are no surprises on either side.
-
Build WEEKS 3–6
We build in weekly increments and demo working software every week: a staging link, a test build on your phone, or a live run of the automation on real data. You see the thing getting real, not slides about it. Feedback goes straight into the next week's work.
You get: a weekly demo, a short written update, and a growing system you can try yourself from the first week.
-
Ship & own ONGOING
Deployment into your accounts, monitoring and alerts, a training session for the people who will use and administer it, and documentation that a new developer could pick up. Thirty days of fixes are included. After that, an optional retainer covers monitoring, iteration and the next idea.
You get: the code, the data, the keys, the documentation, and a team that still answers.
How we communicate,and what we need from you.
How we communicate
A shared Slack channel or WhatsApp group from day one, with the people building your system in it. Questions get answered the same day. A weekly demo call, a short written update after it, and a decision log so nothing agreed in a chat gets lost.
We work in IST and overlap with your hours for calls wherever you are.
What we need from you
One person who can make decisions, available for about two hours a week. Access to the tools and data involved, arranged in Discover. Honest feedback on the weekly demo. And the people who actually do the work today, for an hour or two in the first week; they know where the real problems are.
After launch
Thirty days of fixes are included in every project. Then you choose: run it yourself with the documentation and the accounts in your name, or keep us on a monthly retainer for monitoring, changes and new automations. Retainers are month to month.
Five ruleswe do not bend.
- Written before built
Every system gets a design document you can argue with. Code written before the design is agreed is code we usually throw away.
- Fixed price after Design
Discover and Design are priced up front. The build is quoted fixed once the scope is known, and changes are quoted separately rather than absorbed and resented.
- Working software weekly
If a week passes without something you can click or run, something is wrong, and we say so.
- Boring tech on purpose
Postgres, Python, Node, React, managed cloud. The stack is the stuff that still works in three years without an urgent migration. Clever is reserved for your problem.
- You own everything
Repositories, cloud accounts, domains, API keys and data are created in your name. We work inside them and can be removed with one click.
What people askabout the process.
Can we skip Discover and start building?
For a small, well-understood automation, Discover can be a single workshop rather than a week. We do not skip it entirely; the hour spent with the people doing the work is where most of the design decisions come from.
What if the scope changes during Build?
It happens. Small changes are absorbed. Anything that changes the shape of the system is written up, quoted and scheduled, usually as a second milestone, so the first version still ships on time.
Do you work with our in-house developers?
Yes, and we prefer it. They join the channel, review the design, and take over as much of the system as they want at handover. Everything we build is documented for exactly that.
How do you handle our data and credentials?
Access is granted through your own accounts with the minimum scope needed, credentials live in a secrets manager rather than in code or chat, and we remove our access at the end of the engagement unless you keep us on a retainer.
What does "working demo" mean for an automation nobody sees?
A live run on real or realistic data with the log on screen: the trigger fires, each step reports what it did, and the result lands where it should. If a step is still mocked, we say which one.
How long is a typical project?
Two to six weeks from kickoff to a working first version. Larger systems are split into milestones of that size, each shipped and used before the next starts.
Want to see what we would build? Browse the blueprints.
Nine starting points, each with what it does, what it is built from and how long it takes.