Product launch
Technical documentation
A description of the system complete enough to hand it to another team: architecture, endpoints, environments and the deployment order.
- Reply to your brief
- within 24 hours
- First call
- 30 minutes, no commitment
- First working version
- in 3 weeks
Process
What happens, and when
The work is split into stages, and each one has a named result. You see it yourself rather than reading about it in a report.
Days 1–5
The knowledge inventory
We look at who the documentation is for and why: onboarding a new developer, handing the system to another team, or passing a client’s review — those are three different documents. We take an inventory: what is already written down, what lives only in the code, and what one person knows and nobody else does.
You get — An inventory and the document’s purpose
Weeks 2–3
The system map
We describe the system: which services it is made of, who talks to whom, where the data sits and what happens when each piece fails. The diagrams are drawn from the code and the configuration rather than from the telling — the gaps between how it was meant to work and how it works turn up right here, and go into a list of their own.
You get — A map from the code and its gaps
Weeks 3–4
Endpoints and environments
Endpoints and environments: request, response, error codes, environment variables, and what separates staging from production. Every example is called by hand — anything that does not reproduce stays out of the document, even if the code says otherwise.
You get — Endpoints and environments with examples that ran
Before handover
The deployment order
The deployment order: how to build, how to ship, what to check afterwards and how to roll back if it goes wrong. The document is tried out by somebody else’s hands — they bring an environment up from zero, and every place where they got stuck gets written up.
You get — A deployment guide tested by other hands
When the system changes
Docs beside the code
Documentation goes out of date with the very first release. So it sits next to the code, in the same repository, and is edited by the same task that changes the code; if there is nobody to keep it current, the updating can come to us as a block of hours.
You get — Documentation in the repository, changed with the code
What the work covers
An inventory first
what is already written down, what lives only in the code, and what one person knows and nobody else
How the system fits together
the services, who talks to whom, where the data sits and what happens when a piece fails — drawn from the code
Where it differs from the plan
a separate list of places the system does not work as described — found by checking the map against the code
The endpoints written up
request, response, error codes and worked examples; every example is called by hand, and what does not reproduce stays out
Environments and deployment
the variables, what separates staging from production, how to build, how to ship, what to check and how to roll back
Markdown next to the code
it sits in your repository and changes with the same task the code does; diagrams as source files, the API as OpenAPI
What we need from you
- Your decision on who the document is for — a new developer, another team, or a client’s review
- Two or three hour-long calls with your developers on each piece of the system — code shows what was done, never why
- A staging environment with working keys, so every example in the document can be called by hand
What people usually ask
Contact
Send a description of the task
A reply with the scope, the timeline and a budget estimate comes within 24 hours.
The first call is 30 minutes, with no commitment on your side.
01
You describe the task
Five questions in the form, or a plain email — whichever suits you.
02
We answer within a day
With the scope, the timeline and a budget estimate, based on what you told us.
03
We talk for 30 minutes
To clear up whatever is unclear. It commits you to nothing.