I will write clear technical documentation, user guides and API docs

I will write clear, accurate technical documentation, user guides, and API docs that turn your complex product into something people can actually understand and use without filing a support ticket.

What you get

I research your product, read your code or interface, and write documentation that real users and developers can follow on the first read. Every engagement is built around concrete, reviewable deliverables:

• User guides and how-to articles that walk readers step by step through real tasks, with prerequisites, expected outcomes, and "if this goes wrong" notes.
• API reference documentation covering endpoints, methods, parameters, request and response bodies, status codes, authentication, rate limits, and error objects, written from your actual spec or live endpoints.
• Getting-started / quickstart guides that take a new user from zero to a working first result in the shortest honest path.
• Code examples and request/response samples in the languages you ask for (for example cURL, JavaScript, Python), tested against your endpoints where access is provided so they actually run.
• Conceptual and architecture docs that explain how the pieces fit together, not just which buttons to press.
• Installation, setup, and configuration guides, including environment variables, dependencies, and common gotchas.
• README files, contribution guides, and changelogs that make a repository approachable.
• An edited, consistent terminology and style applied across the whole set, with a short glossary when the product has its own vocabulary.
• Clean Markdown source files (or your preferred format) with proper headings, code fences, tables, and internal links, ready to drop into your docs site, repo, wiki, or knowledge base.
• A revision pass so wording, structure, and examples match what you actually shipped.

You receive ready-to-publish files, not rough notes. If you use a documentation platform such as a static-site generator, GitHub wiki, Notion, Confluence, or a help center, I format the content to fit how that platform renders.

Plans

Plan	Scope	What's included	Revisions
Basic	A single focused document	One user guide, one how-to, or one short API section (a small set of endpoints). Clean Markdown, headings, one round of structure based on your source material.	1 round
Standard	A small documentation set	Several connected guides or a full API reference for a moderate endpoint count, with quickstart, code samples, consistent terminology, and cross-links between pages.	2 rounds
Premium	A complete documentation package	End-to-end docs for a product or full API: getting started, concept docs, task guides, full reference, tested examples, glossary, and a consistent information architecture across the whole set.	3 rounds

Every plan delivers the same standard of clarity and accuracy. The tiers differ in volume and breadth of coverage, not in care. Tell me your endpoint count, feature list, or page outline and I will recommend the plan that fits before we start.

How it works

1. You share the material. Send me what you have: the product or a demo account, API spec (OpenAPI/Swagger, Postman collection, or raw endpoints), existing rough docs, support tickets, or a recorded walkthrough. The more access, the more accurate the result.
2. I scope and confirm. I send back a short outline listing every page or section I'll write, the audience I'm writing for, and any open questions. We agree on scope before a word is written.
3. I research and test. I work through the product or hit the endpoints myself, verify behavior, and note edge cases, error states, and anything the source material gets wrong or omits.
4. I write the first draft. You receive structured, publish-ready Markdown with working examples and a consistent voice.
5. You review, I revise. You flag anything unclear, missing, or off, and I refine within the revision rounds your plan includes.
6. I hand off clean files organized so they slot straight into your docs site, repo, or knowledge base, with a quick note on where each file goes.

Why choose this

I write for the reader who is stuck, in a hurry, and one bad paragraph away from giving up. That means short sentences, accurate steps, and examples that run. I read source code and API specs directly rather than guessing, so the docs describe what your software actually does, not what a marketing page claims. I flag inconsistencies I find along the way, which often surfaces small product bugs and naming mismatches before your users do. You get documentation that lowers your support load, shortens onboarding, and makes your product look as considered as it is.

I'm also honest about scope. If your API has undocumented behavior I can't verify, I tell you instead of inventing it. If a feature is confusing enough that no guide can fully rescue it, I'll say so and suggest the smallest change that would help.

Who it's for / use cases

• SaaS and software teams that shipped fast and never wrote the docs.
• API providers and platform teams who need a reference developers trust.
• Startups preparing for launch, a funding round, or a developer-relations push.
• Open-source maintainers who want a README, contribution guide, and usage docs that grow their community.
• Hardware, IoT, and tooling companies needing setup and configuration guides.
• Internal engineering teams documenting services, runbooks, and onboarding for new hires.
• Product and support teams turning a flood of repetitive tickets into self-serve help articles.

FAQ

Q: What do you need from me to start? Access to the product or a demo account, plus any source material you have: an API spec, existing notes, a feature list, or a short walkthrough. The clearer the access, the more accurate and example-rich the docs.

Q: Can you write API docs from just my codebase or OpenAPI spec? Yes. I work from OpenAPI/Swagger files, Postman collections, source code, or live endpoints. Where I can call the API myself, I verify responses and error cases rather than transcribing the spec blindly.

Q: Will the code examples actually run? When you give me working access to the endpoints, I test the examples I write so they execute as shown. If access isn't available, I build examples strictly from your spec and mark anything I couldn't verify.

Q: What format do you deliver in? Clean Markdown by default, with proper headings, code fences, tables, and internal links. I can also match the structure of your docs platform, wiki, or help center so the files publish without reformatting.

Q: Do you write for end users or for developers? Both, and I keep them separate. I confirm the audience for each document up front and adjust depth, vocabulary, and assumed knowledge accordingly.

Q: How do revisions work? Each plan includes a set number of revision rounds. You review the draft, flag anything unclear, missing, or inaccurate, and I refine. Revisions cover wording, structure, and example fixes within the agreed scope.

Q: Can you update or fix our existing documentation instead of starting fresh? Yes. I can audit what you have, fix inaccuracies, fill gaps, and bring inconsistent pages into one voice and structure. Tell me what exists and I'll scope an update rather than a rewrite.

Q: Do you handle ongoing documentation as the product changes? I can. Many clients start with one set and return to keep docs current as features ship. Share your release cadence and we'll plan recurring updates around it.