An RFC (Request for Comments) process is a written proposal-and-review workflow for decisions too consequential, contested, or cross-functional to settle in a Slack thread. Someone drafts a documented proposal, stakeholders comment against a fixed deadline, one named person decides, and the outcome gets recorded so nobody re-litigates it in six months.

Quick Answer: An RFC process turns one big, contested call into a written document: draft it, open it for a time-boxed comment period, revise where the pushback is real, let one named decider resolve what's left, then record the outcome where the next person can find it.

Distributed product teams reach for this pattern precisely because the alternative — a meeting that only works if everyone's awake at the same time — doesn't scale across time zones. An RFC does the opposite: it front-loads the thinking into a document, lets disagreement surface asynchronously, and produces a decision nobody has to be in the room to witness.

RFCs vs. Decision Logs: Match the Process to the Stakes

A decision log and an RFC solve different problems. A decision log is a one-line record of a call someone already made — low-stakes, reversible, no real disagreement. An RFC exists before the decision, to surface dissent and build agreement on something costly, contested, or hard to undo.

Most PM decisions don't need the ceremony. A pricing tweak inside an already-agreed band, a copy fix, a routine bug-severity call — write it down and move on. The broader discipline of matching the right async tool to the right decision is covered in our complete guide to remote-async PM; an RFC is simply the heaviest tool in that kit, reserved for calls where a lighter one would under-serve the stakes.

Reach for a full RFC when at least three of these are true:

  • The decision is expensive or slow to reverse (a data model, a pricing architecture, a platform migration).
  • It touches three or more teams or functions who don't share a room, or even a working day.
  • Reasonable, informed people currently disagree about the right call.
  • The decision will outlive the people making it — new hires will need the "why," not just the "what."
  • A wrong call would be visible externally — to customers, revenue, or a compliance function.
SignalDecision Log EntryFull RFC
StakesReversible, narrow blast radiusCostly or slow to reverse
StakeholdersOne or two people, already alignedThree or more teams, functions, or time zones
DisagreementNone expectedReal, unresolved disagreement exists
TimelineSame dayDays to weeks, on purpose
OutputOne-line recordFull document, plus a recorded decision

The table is really a filter: if a decision only trips one or two of those signals, log it and move on. An RFC is a cost you pay deliberately, in exchange for a decision that actually holds once it's made.

Where the RFC Process Comes From — and Why Product Borrowed It

Product teams didn't invent this pattern; they adapted it from engineering, which has run written, time-boxed, decision-owning review for decades. The term comes from the IETF's 1969 "Request for Comments" notes, and every modern variant — Rust's RFCs, Google's design docs, architecture decision records — descends from the same core move: put the proposal in writing before you commit.

The Engineering Lineage

The name traces back to Steve Crocker, who circulated the first "Request for Comments" note in 1969 to coordinate what became the early internet — a deliberately humble, non-authoritative way to propose an idea and invite objection. The IETF still runs on that norm: nothing becomes a standard until it has survived open, written review. Modern orgs kept the shape and sped up the clock:

  • Rust's RFC process requires a mandatory 10-day final comment period (FCP) before a contested proposal can merge, giving objectors a hard, known window to speak up.
  • Michael Nygard's 2011 pattern for architecture decision records (ADRs) did the same for smaller, technical calls: a short, numbered document per decision, with a Context, Decision, and Consequences section, filed next to the code it affects.
  • Google's internal design-doc culture, described publicly by engineer Malte Ubl, works the same way at a different altitude — a written proposal, a required review window, named reviewers, and a decision that outlives the meeting it was never held in.
  • Amazon's six-page narrative memo, a non-engineering cousin of the same idea, reportedly opens meetings with silent reading time instead of a slide deck, precisely so debate happens on substance already written down, not on whoever presents best.

What Product Decisions Borrow (and Change)

Product RFCs inherit the mechanics — draft, deadline, decider, record — but change the content. An engineering RFC argues an API shape or a schema; a product RFC argues a positioning call, a pricing model, or a sequencing trade-off that will bind three roadmaps at once.

The audience is wider and less technically uniform, so the writing has to work harder to earn attention across functions. That's the same discipline covered in async documentation and leadership presence: on a distributed team, a leader's word choice and structure in a document is often the only leadership signal anyone actually sees.

The RFC Lifecycle: From Draft to Recorded Decision

A product RFC moves through five stages: draft, open comment period, revise, decide, and record. Each stage has an owner and an exit condition, which is what keeps the document moving instead of sitting open in a shared drive for a month.

  1. Draft. The proposer writes the RFC alone or with one thought partner — not a committee — covering the problem, the options considered, a recommendation, and open questions. A draft marked "ready for comment" should already carry the author's real recommendation; asking "what should we do?" with no proposed answer produces a meandering thread instead of focused debate.
  2. Open comment period. The draft goes to a named list of reviewers, plus anyone who opts in, with a stated close date on the calendar — not "soon." Comments live on the document itself, inline and timestamped, so the reasoning survives the discussion instead of scrolling out of reach in chat.
  3. Revise. The author updates the document in response to real objections, and — this part matters — leaves the original text and the resolved comment thread visible rather than deleting the disagreement. A visible record of "we considered X and rejected it because Y" is often more valuable later than the final decision itself.
  4. Decide. One named decider closes open threads and makes the call, even when full consensus never arrives. Contested RFCs are supposed to surface real disagreement; the decider's job is to resolve it, not wait for it to dissolve on its own.
  5. Record. The decision, its rationale, and the date get written into the document's header or a linked decision log, and the RFC is marked closed. This is the step distributed teams skip most often — and the one that saves the most future time.
StageTypical DurationOwnerExit Criteria
Draft2–5 daysProposal authorDocument states a real recommendation, not just a question
Open comment3–10 business daysAll named reviewersDeadline reached, or every reviewer has signed off early
Revise1–3 daysAuthorEvery substantive comment thread addressed or explicitly declined
DecideSame day comments closeNamed deciderDecision and rationale written down
RecordSame day as decisionAuthor or deciderEntry filed where the next reader will actually find it

Notice what isn't a stage: a meeting. A well-run RFC can go from draft to recorded decision without a single synchronous call — the document does the work a meeting used to do.

The Norms That Keep Async RFCs From Stalling

Three norms separate an RFC that ships a decision from one that dies in a document nobody closes: a hard comment deadline announced up front, a single named decider whose job is to resolve disagreement rather than chase unanimous agreement, and a default bias toward writing over meetings for anything the page can settle.

A Hard Deadline, Not a Soft One

A comment period without a real close date turns into an open-ended waiting game, and distributed teams lose the most to this pattern because "let me know your thoughts" has no natural end across time zones. Put the exact date and time, with a zone, in the document header.

Treat a late comment as valid input only if it arrives before the decider closes the thread — not as a veto that reopens a closed decision. Building the comment window around when your stakeholders actually overlap, rather than picking a number of days out of habit, is exactly the calculation covered in timezone overlap strategy by design.

A Named Decider, Not a Jury

Consensus-seeking is why most product RFCs stall: waiting for unanimous agreement on a genuinely contested call hands one holdout indefinite veto power. Name a single decider in the document header before comments open — usually the DRI (directly responsible individual) for the area the decision touches, not simply the most senior person in the room.

Make clear their job is judgment after hearing dissent, not vote-counting. Disagree and commit, the norm Amazon and others have publicized, exists for exactly this moment: reviewers get a real hearing, then the team moves as one regardless of whether everyone personally agreed.

Write First, Meet Only to Unblock

Default every round of the RFC to async comments on the document; call a synchronous meeting only when a specific thread has gone back and forth three times without converging. A live call at that point should produce a written summary appended to the RFC, not replace the document as the record.

This is one of the recurring habits worth standardizing across a distributed team rather than reinventing each time — see distributed rituals that create alignment for how to build patterns like this into a team's operating rhythm without it feeling like new process for its own sake.

Writing an RFC People Will Actually Read

A product RFC that gets read has six sections in a fixed order: problem statement, context and evidence, options considered, recommendation, risks and open questions, and — once decided — the recorded decision itself. Skipping the options-considered section is the single most common reason a contested RFC turns into a rehash of everyone's existing opinions.

  1. Problem statement. One paragraph, no solution yet: what's forcing this decision now, and what happens if nothing changes.
  2. Context and evidence. The research, data, or customer signal grounding the problem, not an opinion asserted as fact. Grounding a contested product RFC in an actual JTBD framing, the approach covered in our complete guide to Jobs to Be Done, turns "I think users want X" into a claim reviewers can actually argue with. The same goes for evidence pulled from a mapped customer journey: citing the exact moment where the friction shows up is more persuasive than a general assertion that "onboarding is bad."
  3. Options considered. At least two real alternatives, each with honest trade-offs — including the option of doing nothing. A recommendation with no visible alternative reads as a decision already made, and invites review theater instead of real feedback.
  4. Recommendation. The author's actual pick, stated plainly, with the reasoning that connects the evidence to the choice.
  5. Risks and open questions. Named, not buried — what could make this wrong, and what's still unresolved when the comment period opens.
  6. Recorded decision. Appended after the decider closes the RFC: the call, the date, the decider's name, and a one-line rationale.

Keep the whole document under two or three pages before appendices. A nine-page RFC gets skimmed, not reviewed — and a skimmed review produces comments on typos, not on the recommendation.

Bringing the RFC Process Into Your Toolchain

An RFC process works best when the tool mirrors the workflow: a document that supports inline, threaded comments, a visible diff between draft and revision, and a clear marker for "this is decided" versus "this is still open." A generic doc can do this manually; purpose-built review tooling does it by default.

Engineering has had this tooling for years — a pull request already bundles line comments, an approval gate, and a merge in one interface. Product decisions rarely get the same treatment, even though the workflow is identical: propose, comment, revise, approve, ship. Most product RFCs still live in a doc with scattered suggestion-mode edits and a comment thread that's easy to lose track of.

This is precisely the gap Prodinja's Spec Studio is designed to close for product teams specifically:

  • A spec lives as a document that moves through PR-style diffs and inline comments — the same review shape engineers already get from a pull request.
  • A readiness gate marks when a document has actually cleared review, rather than just sat open past its deadline.
  • The stages line up directly: draft, comment, diff, gate, decide — without forcing a product team to bolt engineering review tools onto a document that was never built for one.

Key Takeaways

  • Reserve RFCs for real stakes: costly-to-reverse, multi-team, genuinely contested decisions — everything else belongs in a lightweight decision log.
  • The RFC lifecycle has five stages — draft, open comment period, revise, decide, record — and skipping "record" is the most common failure.
  • A hard, time-zone-aware deadline replaces an open-ended "let me know your thoughts" comment window that never actually closes.
  • Name one decider before comments open. Consensus-seeking on a contested call just hands a veto to whoever stays quiet longest.
  • Ground the RFC in evidence, not opinion — a JTBD framing or a mapped customer-journey moment gives reviewers something concrete to argue with.
  • Keep options considered honest, including the option of doing nothing — a recommendation with no visible alternative invites review theater, not real feedback.
  • Tooling should mirror the workflow: inline comments, a visible draft-to-revision diff, and a clear "decided" marker, the same shape engineering teams already get from pull requests.

Frequently Asked Questions

How is an RFC different from a decision log?

A decision log records a choice that's already been made — low-stakes, low-disagreement, often by one person acting alone. An RFC exists before the decision, to gather dissent and build agreement on something costly or contested; use a decision log for routine calls and save the RFC for the ones that would hurt if you got them wrong and had to unwind them.

How long should the comment period be?

Most product RFCs need three to ten business days, timed to guarantee at least one full overlap window for every named reviewer's time zone rather than a flat number picked out of habit. Shorter than that and reviewers in later time zones effectively get no real chance to weigh in; much longer and momentum dies, so people stop reading closely.

Who should be the decider on a product RFC?

The decider should be whoever is accountable for the outcome if the decision goes wrong — usually the DRI for the area the RFC touches, not the most senior person in the room by default. Naming them in the document before comments open, rather than after debate stalls, is what keeps a contested RFC from drifting into an unresolved argument.

Can an RFC process work for a small team?

Yes, though the ceremony should scale down with team size: a three-person team might skip a formal review meeting and rely entirely on comment threads, but should still keep a hard deadline, one named decider, and a written record. The mechanics that make an RFC work don't require a large team — just a genuinely contested decision.

What happens if reviewers miss the deadline?

A late comment that arrives after the decider has closed the thread becomes input for the next related decision, not a reason to reopen a closed one. Publishing the deadline in the RFC's header up front, and actually holding it, is what makes that fair — reopening a decision every time someone comments late trains a team to never treat a deadline as real.