Geoff Brandt Technical Communications
Your app works.
Your help system doesn’t.
Software documentation and the process work behind it, since 1984. For in-house teams, dev shops that got stuck writing docs nobody wanted to write, and now the AI-built apps that shipped without any.
Help systems, SOPs and process documentation, and white papers.
What I Fix
The product works. The process runs. Nobody wrote either one down.
Here’s what changes once somebody does.
Your users find the answer without emailing you. An empty help search is a lost sale, so the search stops coming up empty, the error messages say what to do next, and the screens that keep tripping people get fixed instead of explained.
Anyone on your team can run your processes, not just the one person who knows how. I document how the work really gets done, find where it breaks, and write the SOP. New hires learn from a document, you can take a week off, and due diligence stops being a problem.
I write the FAQs, in-app help, onboarding copy, error messages, and SOPs. I troubleshoot and design the UI/UX, and I test your processes the way I test your screens, like a stranger would, which is where the real gaps show up.
Built for solo founders and small teams shipping fast. Bigger company, more products, a stakeholder chain? Tell me anyway. I’ll just scope it differently.
Geoff Brandt, CEO GBTC
Why Me?
I’ve been writing software documentation since before “prompt-to-app” was a category – help files, FAQ systems, UI copy, the kind of writing that has to be exactly right because a confused user can’t ask it to clarify. I also run a business consulting practice, so I know what a broken support experience actually costs you in churn, not just in annoyance.
Most people offering documentation work right now learned the format last month. I’ve been doing it since before AI could.
How it Works
Send me your app. I audit it in a day – search, onboarding, error states, help content – and send back what’s actually broken, specifically, not generally. If you want me to fix it, I quote a flat fee and turn it around in days. No retainer, no discovery call (unless you insist), no twelve-page proposal.
System & User Docs
Docs your users actually find.
FAQ pages, in-app help text, and error messages, written from the questions your users actually type into search. The answers your engineering team assumed didn’t need explaining.
I test every step against the live product while I write, so the instructions match the screen your users see.
UI Troubleshooting
The docs are a symptom. I find the cause.
Writing your docs means using your product like a stranger would. And it’s strangers that keep finding the same three or four places people get stuck. I’ve been fixing that since before I fixed it with words.
If the audit turns up friction better copy can’t solve, I’ll tell you exactly where it is and what’s causing it. What you do with that is up to you.
Services
| Service | Price | What it covers |
|---|---|---|
| Help Docs & FAQ | $500–1,500 flat | FAQ pages, in-app help text, error messages |
| Knowledge Base / Help Center Build | $2,000–4,500 flat | Full help center — categories, structure, articles |
| UI Troubleshooting | $1,500–3,000 flat | Friction points found and fixed, not just documented |
| In-App Onboarding Copy | $300–600 flat | First-run walkthrough, tooltips, empty-state copy |
| Launch Copy | $300–500 flat | Product Hunt / App Store listing copy |
| Release Notes | $150–250/mo | Monthly changelog, written from your tickets |
| Error Messages & Empty States | $300–600 flat | Rewritten to say what happened and what to do next |
| Support Macros / Canned Responses | $250–500 flat | Ticket-response templates from your real ticket history |
Prices assume a normal-sized problem. Bigger company, bigger scope, bigger number. I’ll tell you which one you are after I look. End-user and process documentation only. No API references or developer docs.
Tell me what you’re building. I’ll tell you what’s missing.
Full Product Documentation
Sometimes the fix isn’t a page. It’s the whole manual.
Everything above this is a fast fix for a specific gap. This isn’t that.
Some products need the complete functional record — every screen, every flow, every edge case a user can actually hit, documented start to finish. Not what an audit happens to catch in a day. All of it.
This is the work documentation used to mean, before “docs” shrank down to a FAQ page. Enrollment systems. Approval workflows. Applications where a wrong sentence had real consequences, not just an annoyed user. I’ve built full documentation for products at that scale. Most apps aren’t that complicated — but if yours needs the whole manual instead of a patch, that’s what this is.
What’s included:
- Full feature/screen inventory, confirmed with you before work starts
- Complete documentation written to that inventory — not just the loud gaps
- UI/UX friction flagged as I find it, no extra charge
- One structured revision round
| App Size | Price | Timeline |
|---|---|---|
| Small — under ~15 core features/screens | $3,000 – $6,000 flat | 3–5 weeks |
| Mid-size — 15–40 features/screens | $6,000 – $12,000 flat | 6–10 weeks |
| Large / multi-module | Custom quote, starting at $12,000 | Scoped after review |
Tell me what you’ve built. I’ll tell you what it takes to document it right.
SOP & Process Documentation
The process runs. It just runs through one person’s memory.
You didn’t write it down because you didn’t have time, and now you can’t hire, can’t delegate, and can’t take a week off without a phone blowing up. The process runs fine. It just runs through one person’s memory instead of a document. I sit with whoever holds the process, watch them run it, and write down what actually happens, not the version they’d tell you if you asked them to summarize it from memory.
Single Process
The one process that’s currently a liability. Someone’s about to go on leave, quit, or get promoted out of doing it themselves, and nobody else can run it yet.
Scope
- One interview/observation session with whoever runs the process now
- Written SOP: steps in order, decision points, exceptions, who owns it
- One round of revisions
Process Bundle
For a role or a function, not a single task. Built for onboarding a new hire, covering a vacation, or making sure one person leaving doesn’t take the process with them. Covers 5–8 processes depending on complexity, scoped after a short intake call.
Scope
- Intake session mapping which processes need documenting and in what order
- Interview/observation session per process
- Written SOPs in a consistent format, ready to hand to a new hire on day one
- One round of revisions
Full Ops Playbook
Department-wide or company-wide. This is what you build before a sale, before a raise, before you hire a COO, or before due diligence asks “what happens if this person leaves” and you don’t like your answer. Multi-process, multi-owner, built to survive personnel turnover.
Scope
- Full process inventory across the function or company
- Interviews/observation across every process owner involved
- Complete SOP set in a consistent format, indexed and organized for handoff
- One round of revisions
| Scope | Price | Timeline |
|---|---|---|
| Single Process | $400-$900 flat | 3–5 business days |
| Process Bundle (5-8) | $2,000-$4,500 flat | 3-4 weeks |
| Full Ops Playbook | Custom quote, starting at $6,000 | Scoped after review |
Tell me what process is stuck in someone’s head. I’ll tell you what it takes to get it out.
Case Studies, Technical Briefs & White Papers
Your product moved on. The white paper didn’t.
The deck got updated. The website got updated. The PDF your sales team sends to engineers still describes the version from two releases ago.
I write the documents that engineers and buyers read before they talk to you. I interview the people who know the product, write it up so a skeptical reader can check every claim, and send it to your technical reviewer before it reaches anyone else.
Case Study
One customer, one problem, one result. Interview-based, with the numbers and their limits stated.
1-2 pages. Draft 1-2 weeks after the interview. Custom quote, from $600.
Technical Brief
How it works, in a few pages. The mechanism, the architecture, and what the reader needs to evaluate it.
2-4 pages. Draft in about 2 weeks. Custom quote, from $1,200.
White Paper
One position, argued with evidence, built to survive a hostile read-through. Includes a section on what the product does not do, which is the part that gets the paper trusted.
Up to about 12 pages, two interviews, research, and a technical review pass. Draft in 3-4 weeks. Custom quote, from $4,000.
Longer papers, original research, or more interviews are scoped on their own.
What’s included:
- An interview with whoever knows the product, recorded and written up
- A draft written to the claim, not around it
- A technical accuracy pass before delivery
- One structured revision round
Prices assume a normal-sized problem. Everything is custom quoted after I see what you have.
Free audit first, so you know what you have before you pay for what you need.
See the work before you buy it:
Get the Docs Gap Checklist
Ten questions that expose a broken help system in five minutes. The same ones I run before every audit. Drop your email, get the doc. No newsletter attached.
Join the list (over 3000 strong)
You supply the grid paper…