
Tech company, operations team
Internal Tool Build
A custom internal tool that replaces a patchwork of spreadsheets and manual steps with one interface the team owns.
- Industry
- Software & Operations
- Timeline
- 6 Weeks
- Platform
- Internal Web App
- Engagement
- One-off project
Scope
- 6 wk
Build time
One week of discovery, four of building in weekly increments, one for rollout, training and handover.
- 3
Systems connected
A typical first version reads from and writes to the CRM, the billing system and the product database.
- 4
User roles
Views and permissions are designed per role, so each person sees the work that is theirs to do.
- 1 wk
Demo cadence
A working build is shown to the people who will use it every week, and their feedback sets the next week’s work.
Internal tools deserve the same care as the product customers see. The people using them do so all day, and every unclear screen costs time. We design for the person doing the task, then build it properly.
Growing software companies run a surprising amount of their operations on spreadsheets, shared inboxes and admin panels nobody designed. The work gets done, but it depends on a few people remembering the right steps in the right order. This engagement starts by sitting with those people. We document the process as it actually happens, including the workarounds, and identify which steps need a person’s judgment and which are just copying information between systems. That distinction decides what the tool should do and what it should leave alone.



Discovery produces a short specification: the roles involved, the tasks each role performs, the systems that hold the data and the rules that govern each step. We design the main screens around the most frequent tasks first and keep the first version deliberately narrow. Building starts in the second week. We use the client’s existing stack and authentication where possible so the tool fits into their infrastructure and their engineers can maintain it. Integrations are built against real data early, because that is where assumptions tend to break. Every week ends with a demo to the people who will use the tool.
Those demos shape the build more than the original specification does. Users point out the exception nobody mentioned, the field they always need next to another, the step that should be undoable. We adjust the plan each week and keep a visible list of what is in the first version and what is deferred. The final week covers permissions, audit logging, documentation and a rollout that runs the new tool alongside the old process until the team is confident. Handover includes the repository, deployment notes and a walkthrough with the engineers who will own it.

How we work
- Discovery happens with the people doing the work. The tool is modeled on the real process, workarounds included.
- The first version is narrow on purpose. It covers the most frequent tasks well and defers the rest to a visible list.
- It is built on the client’s stack with their authentication, so their engineers can run and extend it after handover.
- A working build is demoed every week. Feedback from users sets the priorities for the following week.
The operations team ends up with one tool that holds the process, in place of a set of habits spread across documents and inboxes. New team members can follow it without a guide, and the engineers who inherit it have the code, the documentation and the context to keep improving it.
The same approach applies to other custom work: a new feature inside an existing product, a rework of an admin area, or a small application that connects two systems. In each case we start from the task, keep the first version small and build in the open with weekly demos. Because the result lives in the client’s own infrastructure, there is no dependency on us to keep it running. Many teams come back with the deferred list a few months later, once they have used the tool enough to know what matters. The figures on this page describe a typical first version; more integrations or roles extend the build by weeks, not by a different process.




