Stop losing decisions in
Slack threads and Google Docs
DesignDoc gives every RFC a structured workflow, inline reviews, and a permanent searchable home — so your team never asks “why did we build it this way?” again.
CLI + MCP + Web · Built for engineering teams
## Detailed Design
The new billing engine introduces two
core abstractions:
1. `BillingPlan` — defines pricing tiers
2. `UsageMeter` — tracks consumption
```mermaid
graph LR
A[User] --> B[BillingPlan]
B --> C[UsageMeter]
C --> D[Invoice]
```
│
Detailed Design
The new billing engine introduces two core abstractions:
BillingPlan— defines pricing tiersUsageMeter— tracks consumption
Should UsageMeter support real-time streaming or is batch aggregation sufficient for v1?
You've been here before
Design decisions happen everywhere — and disappear just as fast.
Lost in Slack
A critical architecture decision made in a thread. Two weeks later, nobody can find it. The new hire rebuilds the same thing differently.
Rotting in Google Docs
50 design docs in a shared drive. No workflow, no status. Half are drafts, half are abandoned. Which ones are actually approved?
Tribal knowledge
"Ask Sarah, she was here when we chose Kafka." But Sarah left. Now it's folklore — no written record of the trade-offs or context.
Everything your RFC process needs
Not another wiki. A purpose-built tool for engineering decisions.
Structured Workflow
Every RFC moves through clear states — Draft, In Review, Accepted, Implementing, Done. Each transition is tracked with timestamps and actors.
Rich Markdown Editor
Split-pane editor with live preview. Mermaid diagrams, KaTeX math, syntax-highlighted code blocks, tables, and task lists built in.
Inline Comments & Reviews
Leave feedback on specific sections. Request reviews from teammates. Resolve threads as you iterate. Like code review, but for design docs.
Full-Text Search
"Why did we pick Postgres over MySQL?" One search, instant answer. Every decision findable in seconds — even years later.
AI-Native (MCP Server)
Claude, Cursor, and Copilot can query your decisions while writing code — so they follow your team's actual conventions, not generic patterns.
Public Portal
Share public RFCs externally, keep private ones locked. One clean URL your team always knows.
From idea to permanent record
Three steps. Clear path. No decisions lost.
Write
Start from a structured template — summary, motivation, design, alternatives. The split-pane editor shows live Markdown preview as you type.
Review
Request reviews from teammates. They leave inline comments on specific sections. Iterate, resolve threads, and refine until the proposal is solid.
Decide
Accept, reject, or send back for revision. Every transition is recorded with context — building your team's searchable decision history forever.
Why not just use…?
General-purpose tools aren't built for structured decisions.
| designdoc | Google Docs | Notion | Confluence | |
|---|---|---|---|---|
| RFC workflow states | plugin | |||
| Inline section reviews | basic | |||
| Decision audit trail | ||||
| AI/MCP integration | ||||
| CLI & MCP access |
Built for every engineer in the room
Tech Leads
Write RFCs, get structured feedback, and drive decisions to completion without chasing approvals.
Eng Managers
See which decisions are pending, stale, or blocked. Know if your RFC process is actually working.
IC Developers
Understand why things were built a certain way. Search past decisions before starting implementation.
Solo Builders
Document decisions for your future self. Revisit a project in 3 months and know exactly why.
Understanding RFCs & design docs
New to RFCs? Curious how top engineering teams make decisions?
What is an RFC?
Request for Comments originated at the IETF in 1969. Today, engineering teams use RFCs to propose, discuss, and document architectural decisions before writing code.
Read more Best PracticeWhy document decisions?
Six months from now, nobody will remember why you picked Kafka over RabbitMQ. A written record captures the context, trade-offs, and reasoning — before it's lost.
Read more TemplateAnatomy of a good RFC
Summary, motivation, detailed design, alternatives considered, migration plan, and open questions. A structured template turns scattered thoughts into clear proposals.
Read moreYour team's decisions
deserve a real home.
Start documenting your team's decisions today.
CLI + MCP + Web · Built for engineering teams