DocRepeat — The Word Add-In That Detects Repetitive Edits and Automates Them Forever
Clerical workers spend 3-4 hours a day making the same find-replace-reformat edits in Word documents because VBA macros require a developer and built-in AutoCorrect is embarrassingly dumb. DocRepeat watches your edits, spots the pattern after 3 repetitions, and offers to automate it with one click — no macro writing required.
Difficulty
intermediate
Category
Business Automation
Market Demand
High
Revenue Score
7/10
Platform
VS Code Extension
Vibe Code Friendly
No
Hackathon Score
6/10
Validated by Real Pain
— sourced from real community discussions
Clerical workers on Reddit describe spending hours daily on repetitive Word edits they cannot automate without VBA knowledge, and existing solutions like AutoCorrect and find-replace are too limited for complex formatting patterns.
What is it?
Office admins and legal secretaries on Reddit threads describe spending entire days doing identical Word edits — swapping boilerplate clauses, reformatting table columns, replacing client names — that VBA could handle if anyone knew how to write VBA. DocRepeat is a Word task pane add-in built with Office.js that passively logs edit patterns, uses Claude to identify the automation rule, and surfaces a one-click automation button when a pattern repeats 3+ times. The $19/month price point is below any admin assistant hourly cost. Buildable right now because Office.js add-ins deploy via the Microsoft 365 admin portal with no App Store approval cycle, and Claude's function-calling API can translate natural-language edit patterns into reliable find-replace-transform rules without any custom model training.
Why now?
Office.js add-in deployment via Microsoft 365 admin portal became frictionless in 2024, and Claude function-calling now reliably converts edit patterns to executable rules — the technical stack to build this did not exist 18 months ago.
- ▸Office.js task pane passively logs user edits and detects repeated patterns after 3 occurrences without interrupting workflow.
- ▸Claude API translates the detected pattern into a plain-English automation rule the user confirms before activating.
- ▸One-click automation applies the confirmed rule to the entire document instantly.
- ▸Automation library saves all confirmed rules per user so they persist across documents and sessions.
Target Audience
Clerical workers, legal secretaries, and office admins — estimated 4M+ in the US alone using Word daily.
Example Use Case
Maria, a legal secretary at a 10-person firm, installs DocRepeat and within one afternoon it detects she reformats every contract date the same way — one click automates it, saving her 45 minutes every document.
User Stories
- ▸As a legal secretary, I want Word to detect when I keep making the same formatting edit, so that I can automate it without writing any macros.
- ▸As an office admin, I want a library of my saved automations, so that I can reuse them across every document without reconfiguring them.
- ▸As a team manager, I want to share automation rules with my whole admin team, so that everyone works with consistent document standards.
Done When
- ✓Pattern detection: done when user makes 3 identical text edits and sees a notification in the task pane identifying the pattern.
- ✓Rule confirmation: done when user clicks Confirm and the plain-English rule description matches what they actually did.
- ✓Automation execution: done when confirmed rule is applied to all matching text in the document and user sees a count of changes made.
- ✓Rule persistence: done when user closes and reopens Word and confirmed rules still appear in the automation library.
Is it worth building?
$19/month x 100 users = $1,900 MRR at month 3. $19/month x 500 users = $9,500 MRR at month 8. Math assumes 2% conversion from LinkedIn ad targeting office admin job titles.
Unit Economics
CAC: $25 via LinkedIn ads at $15 CPC with 60% trial-to-page conversion and 2% trial-to-paid. LTV: $228 (12 months at $19/month). Payback: 2 months. Gross margin: 78%.
Business Model
SaaS subscription
Monetization Path
Free tier: detect patterns only. $19/month: unlimited automations. $49/month team: 5 seats.
Revenue Timeline
First dollar: week 3 via beta upgrade. $1k MRR: month 3. $5k MRR: month 9. $10k MRR: month 15.
Estimated Monthly Cost
Claude API: $30, Vercel/Railway: $20, Supabase: $25, Stripe fees: $15. Total: ~$90/month at launch.
Profit Potential
Sustainable solo founder income at $5k-$8k MRR.
Scalability
Medium-high — team plans and enterprise Microsoft 365 deployment are natural upsells.
Success Metrics
Week 2: 20 add-in installs. Month 1: 15 paid. Month 3: 80 paid, under 20% churn.
Launch & Validation Plan
Post a 60-second screen recording in r/MicrosoftWord and r/adminprofessionals showing pattern detection, collect 30 upvotes before building.
Customer Acquisition Strategy
First customer: post demo video in r/adminprofessionals and r/legaladvice offering free beta to the first 10 who DM. Ongoing: LinkedIn ads targeting Office Admin and Legal Secretary job titles at $15 CPC, aim for 2% trial conversion.
What's the competition?
Competition Level
Low
Similar Products
Microsoft Word built-in AutoCorrect (too simple, no pattern detection), VBA macros (require developer), Zapier (not Word-native) — none passively detect and automate edit patterns inside the document.
Competitive Advantage
Zero VBA knowledge required, pattern detection is passive so zero learning curve, 10x cheaper than hiring even part-time admin help.
Regulatory Risks
Document content processed by Claude API — must document data handling in privacy policy and offer an on-premise mode for law firms handling privileged content.
What's the roadmap?
Feature Roadmap
V1 (launch): pattern detection, rule confirmation, single-document automation, rule library. V2 (month 2-3): Excel support, rule export/import. V3 (month 4+): team rule sharing, enterprise 365 deployment.
Milestone Plan
Phase 1 (Week 1-2): Office.js add-in installs, edit logging works, Claude rule detection fires. Phase 2 (Week 3-4): Stripe gating live, 10 beta users running real automations. Phase 3 (Month 2): 50 paid users, rule library polished, Excel scoped.
How do you build it?
Tech Stack
TypeScript, Office.js Add-in SDK, Claude API, Node.js Express backend, Supabase, Stripe — build with Cursor for all logic, v0 for task pane UI.
Suggested Frameworks
Office.js, Anthropic Claude API, Express.js
Time to Ship
3 weeks
Required Skills
Office.js add-in development, Claude API function calling, Stripe billing, TypeScript.
Resources
Microsoft Office Add-ins docs, Office.js API reference, Anthropic function-calling docs, Stripe Node SDK.
MVP Scope
taskpane/index.html (Office.js task pane UI), taskpane/app.ts (edit event listener + pattern logger), api/detect.ts (Claude pattern detection endpoint), api/apply.ts (automation execution endpoint), lib/rules.ts (rule serialisation), db/schema.sql (users + rules tables), manifest.xml (Office add-in manifest), .env.example (required env vars).
Core User Journey
Install add-in -> make 3 identical edits -> see pattern detected notification -> confirm automation -> watch it apply to full document.
Architecture Pattern
Office.js edit event -> pattern buffer in localStorage -> API call to Claude detect endpoint -> rule confirmed by user -> apply endpoint executes Word transformation via Office.js.
Data Model
User has many Rules. Rule has pattern description, transformation logic, trigger count, and active flag. User has subscription tier.
Integration Points
Office.js for Word document access, Claude API for pattern-to-rule translation, Stripe for subscriptions, Supabase for user data and rule storage.
V1 Scope Boundaries
V1 excludes: Excel support, PowerPoint, team rule sharing, on-premise deployment, custom AI model fine-tuning.
Success Definition
A legal secretary at a firm the founder has never contacted installs the add-in, confirms an automation, and upgrades to paid without any support email.
Challenges
Office.js sandboxing limits what document events can be intercepted — some edit types require workarounds. Distribution is the real blocker: clerical workers do not browse ProductHunt, so LinkedIn ad targeting by job title and admin Facebook groups are the only realistic channels.
Avoid These Pitfalls
Do not attempt to intercept every possible Word edit event on day one — start with find-replace and text substitution patterns only. Do not send full document content to Claude — send only the before/after diff of the detected pattern to minimise cost and privacy risk.
Security Requirements
Supabase Auth with magic link. RLS on rules table scoped to user ID. Only edit diffs sent to Claude — never full document content. Rate limit 20 Claude calls per user per day.
Infrastructure Plan
Office.js task pane hosted on Vercel, Express API on Railway, Supabase for DB, GitHub Actions for CI/CD, Sentry for error tracking. Total infra ~$90/month.
Performance Targets
Pattern detection must fire within 500ms of the third matching edit. Claude rule generation target under 3 seconds. Task pane load target under 1.5 seconds.
Go-Live Checklist
- ☐Security audit complete.
- ☐Payment flow tested end-to-end.
- ☐Error tracking (Sentry) live.
- ☐Monitoring dashboard configured.
- ☐Custom domain set up with SSL.
- ☐Privacy policy and terms published.
- ☐5+ beta users signed off.
- ☐Rollback plan documented.
- ☐Launch post drafted for ProductHunt and Reddit.
First Run Experience
On first run: task pane shows a welcome screen with a 30-second animated demo of pattern detection. User can immediately start editing their open document — no configuration required. No manual config required: pattern logging starts automatically on add-in load.
How to build it, step by step
1. Define Supabase schema: users table, rules table with pattern JSON and transformation JSON fields. 2. Scaffold Office.js task pane add-in with the Yeoman Office generator using TypeScript. 3. Implement edit event listener in app.ts that logs last 20 text change events to localStorage. 4. Build pattern comparison function that flags when 3 edit events share the same structure. 5. POST the before/after diff to Express API endpoint that calls Claude to generate a plain-English rule and a transformation function. 6. Render the detected rule in the task pane with a Confirm and Automate button. 7. On confirmation, save the rule to Supabase and execute the transformation across the document via Office.js search-and-replace. 8. Wire Stripe checkout to unlock unlimited rule saves beyond the 3-rule free tier. 9. Build the rules library view in the task pane showing all saved automations with enable/disable toggles. 10. Verify: open a test Word document, make 3 identical edits, confirm the automation fires correctly on the fourth occurrence end-to-end.
Generated
June 15, 2026
Model
claude-sonnet-4-6
Disclaimer: Ideas on this site are AI-generated and may contain inaccuracies. Revenue estimates, market demand figures, and financial projections are illustrative assumptions only — not financial advice. Do your own research before making any business or investment decisions. Technology availability, pricing, and market conditions change rapidly; always verify details independently.