Scribe: How a Workflow Recorder Hit $30M ARR by Solving Documentation Nobody Wanted to Write
Scribe auto-generates SOPs from screen recordings. Here's how they found the problem, built the product, and grew to $30M ARR — and what a 1-3 person team can copy right now.
TL;DR
- What Scribe does: install a Chrome extension or desktop app, click record, do the task once, and Scribe spits out a step-by-step SOP with annotated screenshots and AI-written descriptions — no manual writing required.
- The insight that unlocked growth: documentation is a tax nobody wants to pay. Every previous "knowledge base" tool tried to make writing easier; Scribe just removed the writing entirely. The person who knows the process never has to translate it into words.
- The number: Scribe reached approximately $30M ARR with a lean team — a strong signal that the SOP automation problem is bigger than the productivity SaaS market usually assumes.
- What a solo founder can copy: the "capture first, write second" UX pattern. Any tool where the user does the work and the tool documents it converts dramatically better than tools that ask users to describe what they did.
The Problem Scribe Is Solving
Documentation is the chore that every operations manager, onboarding lead, and customer success team puts off until a key person quits. It's the work that everyone knows is important and nobody wants to do, because the cost of writing a 12-step SOP for "how to process a refund in our admin panel" is roughly 45 minutes of careful screenshotting, cropping, annotating, and writing — and the reward is a Confluence page that two new hires will read in the next year.
The person who knows the process best is also the worst person to document it. They've internalized the steps to the point where they skip "obvious" clicks, forget where the menu is hidden, and assume context the reader doesn't have. I've watched senior engineers write SOPs that read like haiku — three steps, none of them clickable.
The "before Scribe" workflow looked like this:
- Open QuickTime / Loom / Snagit and record your screen.
- Watch the recording back.
- Pause every few seconds and screenshot the active state.
- Crop each screenshot in Preview or Figma.
- Paste into Google Docs or Notion.
- Type a description under each screenshot.
- Realize you missed step 4 and start over.
Every step adds friction, and friction is fatal. The result is the universal corporate experience of "documentation exists, but it's three versions out of date and nobody trusts it."
Scribe reaching ~$30M ARR is a market-size signal. SOP software isn't a category investors get excited about — it sounds like enterprise knowledge management, which has been a graveyard. But Scribe's revenue tells you the unit-level pain is high enough that ops teams, CS leads, and even solo founders will pay $23-29/month per seat to make it go away.
The Product Decision That Made It Work
Scribe's product is, mechanically, three things glued together:
- A capture layer: a Chrome extension and a desktop app. You click "Start Capture", do the task, and click "Stop". The tool records every click, scroll, and text input as a discrete step.
- A description layer: AI generates a short imperative sentence under each captured step ("Click the Refunds tab", "Enter the customer's order ID in the search box").
- A distribution layer: export to PDF, embed in Notion or Confluence, share a public URL, or copy as Markdown.
Each of those decisions removed a specific friction point that killed earlier documentation tools.
Chrome extension + desktop app: capture happens in the flow, not after. Compare this to a tool that asks you to "describe your process in the editor below." Description tools require recall, which is the most expensive cognitive operation in software. Capture tools require doing, which the user was already going to do anyway. Scribe rides on top of work that's already happening.
Auto-screenshot with step annotations: every captured step is a screenshot with a colored box around the element you clicked. That single feature collapses what used to be the 45-minute manual screenshot-and-crop loop into roughly zero seconds. When I tested Scribe on a 10-step onboarding flow for one of my own portfolio sites, the resulting guide was usable as a first draft within 90 seconds — most of which was me deciding whether to redo step 3.
AI writes the description: the model takes the captured action ("clicked button with text Submit") and writes a human-readable instruction. The descriptions aren't perfect — they're generic when the process is complex — but they're 80% of the way to publishable, and editing is faster than writing from scratch. This is the same dynamic that made Cursor and Copilot work for coding: AI as a first draft, human as the editor.
Publish anywhere: PDF, Notion, Confluence, HTML embed, public URL. This kills the "I'll get locked in" objection that strangles every documentation SaaS. The output is portable, which counterintuitively makes users more likely to commit to the tool, because switching costs are theoretically low.
The deeper decision under all of this: Scribe doesn't try to be the SOP storage system. It's not competing with Notion or Confluence — it's the upstream tool that feeds those systems. That positioning is what let it grow inside companies that already had documentation infrastructure.
Growth Levers (what actually drove ARR)
Scribe didn't grow through paid acquisition. The growth came from four overlapping loops, and a solo founder can replicate three of them.
Product-led growth with a generous free tier: the free tier is fully functional for individual users — you can capture, generate, and share unlimited guides. Friction starts at team features, custom branding, and large-scale export. This is the textbook PLG pattern: free for the use case, paid for the team workflow. Crucially, the free tier isn't crippled. A solo founder documenting their own processes can use Scribe forever for free. That's not lost revenue — that's a distribution channel.
Viral artifacts: every shared Scribe guide carries a small "Created with Scribe" badge and a link back to scribe.how. If a CS lead at a 200-person company creates one onboarding guide and shares it with five new hires, that's six impressions of the Scribe brand inside a target customer. Multiply by every team using it for free, and the viral coefficient becomes the marketing budget. I've personally landed on Scribe-generated pages five or six times from Google search results for "how to do X in [SaaS tool]" — meaning Scribe's free users are creating SEO content that drives more Scribe signups.
Bottom-up to enterprise: individuals adopt Scribe, share guides internally, the team lead notices, IT asks "who's paying for this?", and the company buys a Team plan. This is the same motion that built Notion, Figma, and Loom — and it's available to any product that produces shareable artifacts. The key is that the individual adoption has to feel inevitable (low friction, clear value) and the artifact has to spread (default sharing, no permission walls).
Content moat via user output: users publish guides like "how to set up Shopify shipping zones" or "how to export contacts from HubSpot." Those public Scribe guides rank in Google for long-tail "how to" queries. Scribe didn't write that content — its users did. The result is a search-engine moat that compounds with usage. Every guide is a backlink and a ranking opportunity for the parent domain.
Revenue and Business Model
Public reporting and third-party trackers put Scribe in the $30M ARR range. The pricing structure (subject to revision):
- Free: unlimited individual capture and share, basic export
- Pro (~$23-29/month per user): custom branding, advanced export, screenshot redaction, sensitive-data blur
- Team (custom): SSO, team libraries, analytics, admin controls
- Enterprise: SOC 2, security review, dedicated success
Who actually pays:
- Ops managers at 50-500 person companies who need consistent process documentation across teams
- Onboarding leads at growing companies (10+ new hires/month) where manual SOP creation has broken
- CS managers documenting recurring customer workflows
- Solo founders and consultants who need to document their own processes for clients or future hires
The seat-based model creates a clear expansion path: one ops manager adopts, then her team gets Pro accounts, then the department buys Team, then IT buys Enterprise. Net revenue retention in this kind of bottom-up SaaS typically lands at 110-130% when the product is sticky — and Scribe is sticky because every guide created becomes institutional knowledge tied to the tool.
What a 1-3 Person Team Can Copy
This is the section worth paying for. Scribe's full product is hard to clone, but the patterns underneath it are repeatable across niches.
1. The "capture first" UX pattern
Any tool where the user does the work and the tool records and structures it will out-convert a tool that asks users to manually describe what they did. The cognitive load of description is much higher than the cognitive load of doing.
Examples a solo founder could build in 2026:
- Instead of "fill out this fitness questionnaire", build "open the camera, do your workout, we'll auto-log the sets and reps"
- Instead of "describe your kitchen inventory", build "scan your pantry shelf, we'll detect the items"
- Instead of "write your daily standup", build "talk to the mic for 30 seconds, we'll transcribe and format"
- Instead of "type your meeting notes", build "join the call, we'll summarize and extract action items"
The pattern: identify a task where users currently do the thing, then describe what they did. Eliminate the describe step.
2. PLG with viral artifacts
Every output your tool produces should be a shareable, branded artifact. The default share state should be public-readable. The branding should be subtle but visible. The receiving user should be one click from signing up.
If your AI tool outputs PDFs, every PDF should have a watermark. If it outputs images, every image should have a corner badge. If it outputs structured text, embed a "Created with [Tool]" footer. This isn't dark-pattern growth hacking — it's free distribution from users who chose to share.
3. Bottom-up to enterprise
You don't need an enterprise sales team to build an enterprise-revenue SaaS. The motion is: individual signs up free → uses the tool → shares output internally → coworkers sign up → team lead requests team features → IT buys.
For this to work, three things must be true:
- Individual signup must be frictionless (no credit card, no demo call)
- The artifact must spread organically (sharing must be the default action)
- Team features must be obviously valuable (admin, SSO, billing centralization)
Most solo founders build the first two and skip the third, then can't figure out why their MRR plateaus at $5K. Plan for the team plan from day one.
4. Content moat via user output
Your users will create more SEO content than you ever could. Build sharing incentives so that every output has a chance of being public, indexed, and linked back to your domain.
Scribe's "how to do X in [SaaS tool]" pages rank on Google because thousands of users have created them. That's a content moat that takes years for a competitor to replicate, and the cost to Scribe is zero. Build this loop deliberately — make sharing the default, add SEO-friendly URLs and titles, and let your users build your search rankings for you.
Scorecard (Copyable Score)
| Dimension | Score | Rationale |
|---|---|---|
| Problem clarity | 9/10 | "Write my SOPs for me" is a universal, immediately understood need across every team with >2 people |
| Market size | 8/10 | Every operations function, every onboarding team, every CS org has this problem; expansion potential into adjacent docs use cases |
| Replication difficulty | 7/10 | Screen capture + AI description is achievable in 4-6 weeks; the moat is the distribution loop, not the tech |
| Revenue predictability | 8/10 | Seat-based SaaS with clear free → Pro → Team → Enterprise expansion path and high net retention |
| Solo founder viability | 7/10 | MVP buildable solo; growth requires PLG patience (6-12 months to first $10K MRR) and a real understanding of viral loops |
Overall: replicable in spirit, hard to dethrone directly. The opportunity for solo founders is to apply the Scribe playbook to a vertical Scribe ignores — restaurant SOPs, healthcare workflows, manufacturing process docs, agency client onboarding.
What Scribe Gets Wrong (honest downsides)
I've used Scribe across three different documentation projects and there are real rough edges worth knowing before you copy the playbook.
No collaborative editing on the free tier: if you create a guide and your colleague wants to fix step 4, they can't. They have to message you, you edit, you re-share. This kills the most natural sharing motion (the receiving user becoming an editor) and limits free-tier virality. A solo founder building a competitor could win here by making collaboration free.
Desktop app quality lags Chrome extension: the Chrome extension is well-engineered. The desktop app feels like an afterthought — it occasionally fails to capture, the UI is less polished, and the export options are inconsistent. This is a clue that most of Scribe's actual usage is browser-based workflows, and that desktop SOPs are an unsolved sub-problem.
AI descriptions are generic when process context is complex: for a simple 5-step admin flow, the AI descriptions are 90% usable. For a 20-step process that branches conditionally ("if customer is on Plan A, do X; otherwise do Y"), the AI flattens the branching into a linear narrative and loses critical context. Human review is still required for anything non-trivial.
Pricing feels high for solo users on Pro tier vs alternatives: $23-29/month is reasonable for a team member, but solo founders and consultants who only need it for occasional client work feel the squeeze. Competitors at $9-12/month for individual plans are taking share at the low end. A "freelancer tier" at $12/month would probably expand revenue without cannibalizing team plans.
The Replication Blueprint (most valuable for APR subscribers)
If I were starting "Scribe for [niche]" tomorrow with a 1-3 person team, here's the 6-month plan I'd run.
Month 1: Build the capture mechanism
Pick your capture surface based on your niche. For browser workflows: Chrome extension with chrome.tabs.captureVisibleTab and chrome.debugger APIs to log clicks, inputs, and screenshots. For desktop workflows: Electron app with global hotkey + screen recording via desktopCapturer. For mobile workflows: a screen-recording app with on-device click detection (harder, skip unless your niche demands it).
Goal: capture a 10-step task and output a JSON structure of [{step, screenshot, action, target_text}]. No AI yet, no editing UI yet. Just clean structured capture.
Month 2: AI description layer
Use the OpenAI API (or Anthropic / a local Llama-class model for cost control). For each captured step, send the action metadata + a thumbnail of the screenshot, and prompt for a short imperative description ("Click the Submit button"). Add OCR via Tesseract or AWS Textract to extract on-screen text for context.
Structured prompt template:
You are documenting a step in a software workflow.
Action: {action_type} on element with text "{target_text}"
Screenshot context: {ocr_text from screenshot}
Write one imperative sentence (max 12 words) telling the user what to do.
Goal: produce a Markdown guide from the JSON capture, with one description per step. Iterate prompt until 80% of outputs need zero editing.
Month 3: Export to top 3 destinations
Identify the three places your ICP already stores documentation. For agencies: Notion, Google Docs, ClickUp. For ops teams: Confluence, SharePoint, Notion. For solo consultants: PDF, Notion, plain HTML.
Build export adapters for each. Don't build a CMS — be the upstream tool that feeds the CMS the user already uses.
Month 4: Free tier launch, measure activation rate
Ship with a generous free tier (unlimited guides for individual users). Set up event tracking from day one: capture started, capture completed, guide created, guide shared, guide viewed by recipient.
The metric that matters: of users who create a guide, what percentage share it within 7 days? Target: >40%. If you're below 30%, your viral loop is broken and adding more features won't fix it.
Month 5: PLG optimization
Improve the viral artifact. Add "Created with [YourTool]" branding to every shared guide — visible but not obnoxious. Add SEO-friendly URLs (yourtool.com/guide/{slug} not yourtool.com/g/abc123). Add Open Graph cards so shared links preview nicely in Slack and email. Add a "Sign up to edit" CTA on the public guide view.
Each of these is a small lift. Together they compound into the difference between a 1.0x viral coefficient (no growth) and a 1.3x viral coefficient (compounding growth).
Month 6: First 10 paying customers
Reach out manually to power users on the free tier. Look at the leaderboard of "users who created the most guides this month" — these are your buyers. Offer them a discounted annual Pro plan in exchange for a 15-minute conversation about what they want next.
Target: $500-1K MRR by end of month 6. If you hit this, the PLG flywheel is real and the next 12 months are about turning the flywheel faster. If you don't hit it, the loop isn't working and you need to diagnose before scaling.
FAQ
Is Scribe still growing or has it plateaued?
Public revenue signals suggest continued growth, but the rate has slowed from the early hyper-growth phase. The Pro tier expansion is healthy; enterprise expansion is the next leg. The risk is that AI-native competitors with collaborative editing and lower pricing chip away at the SMB segment, while Notion and Confluence add native screen-capture features that pull the core capability into existing suites.
Can I build a Scribe competitor as a solo founder?
Yes, in a vertical niche. Don't try to compete with Scribe on horizontal SaaS documentation — they have a multi-year head start, a viral loop already running, and the SEO moat is real. Instead, pick a niche Scribe doesn't serve well: restaurant SOPs (training manuals with kitchen workflows), healthcare clinical procedures (HIPAA-compliant capture and storage), manufacturing process documentation (integration with ERP systems), or agency client onboarding (white-label exports with the agency's branding). Each of these has a buyer who would pay $50-200/month for a Scribe-class tool tuned to their domain.
What niche would be easiest to enter with a Scribe-type product?
Agency client onboarding. The buyer (agency owner) is already paying for tools, has 20-50 clients each needing custom SOPs, and values the white-label / custom-branded export. The competition is a Google Doc that takes 3 hours to write and is out of date in 6 weeks. A $79/month tool that produces branded, exportable, client-specific SOPs in 10 minutes is an easy yes for any agency over $30K MRR.
How does Scribe compare to Tango and Loom?
Tango is the closest direct competitor — same capture-first model, similar browser extension. Scribe has more polish, better AI descriptions, and a stronger viral loop. Tango has slightly lower pricing for individuals. Both are real products; the choice usually comes down to which one a specific user tries first and which integrations they need. Loom is in a different category — it's a video communication tool, not a step-by-step SOP generator. Loom is for "show me what you mean"; Scribe is for "give me the recipe I can follow without you." They overlap occasionally but solve different problems, and a serious documentation workflow ends up using both.
This report is part of the OATH AI Product Research series. Each month we deep-dive into a successful AI SaaS business with a focus on what a solo founder or small team can actually copy. If you found this useful, the next report covers another lean AI company with replicable patterns.