What Miro actually does
Miro is the world's leading collaborative whiteboard platform, founded in 2011 in Perm, Russia as RealtimeBoard by Andrey Khusid and Oleg Shardin. The company rebranded to Miro in 2019 and moved its headquarters to Amsterdam and San Francisco. As of September 2025, Miro serves 90M+ users across 250,000+ organizations (Miro newsroom, Forbes Cloud 100). Revenue reached approximately $665M ARR in 2024 (Sacra estimate), up ~5.6% year-over-year from ~$630M ARR in 2023. Miro's last disclosed valuation was $17.5B from its Series C in January 2022 ($400M ICONIQ-led).
Miro's core product is an infinite canvas whiteboard with real-time multi-user collaboration. Teams use it for remote workshops, product planning, design sprints, brainstorming, and diagramming. The platform has evolved significantly beyond whiteboards to include AI-powered diagramming (AI Workflows with Sidekicks and Flows), a template library of 5,000+ entries, and advanced presentation and voting tools.
Miro runs on AWS infrastructure. The platform's key limitation that drives upgrade pressure is the free tier's 3-board cap — teams hit this within days of starting, making it one of the most aggressive free-to-paid conversion mechanics in SaaS. At $16/user/mo Business, Miro becomes expensive quickly at scale. The CRDT infinite canvas architecture puts this at 9/10 complexity — one of the hardest consumer SaaS products to build from scratch.
Infinite canvas with pan/zoom
An infinitely scrollable and zoomable canvas that renders objects at any scale with smooth 60fps performance. The rendering engine must handle thousands of concurrent objects without performance degradation. This is the core technical challenge of a Miro alternative.
Real-time multi-user collaboration
Multiple users editing the same board simultaneously with changes propagated in real-time via CRDTs. Cursor presence, live object movement, and concurrent editing without conflicts are the collaboration foundations.
Sticky notes, shapes, connectors, and drawing tools
The standard whiteboard primitives: sticky notes (text boxes), shapes (rectangles, circles, arrows), freehand drawing, and connector lines with labels. These objects must support grouping, alignment, and bulk operations.
Templates library for workshops and diagrams
5,000+ templates covering retrospectives, sprint planning, flowcharts, mind maps, org charts, and UX flows. Templates are a primary acquisition channel and onboarding tool — users search for a template before exploring the free-form canvas.
AI Workflows (Sidekicks and Flows)
AI-powered diagramming assistance (Flows) and conversational AI board help (Sidekicks). Available on Business tier with credit limits. Teams report burning through monthly AI credits in two workshop sessions.
Comments, votes, and timer widgets
Threaded comments anchored to objects, anonymous or attributed voting on sticky notes (for retrospectives and prioritization), and a built-in timer for time-boxing workshop activities. These facilitation features differentiate Miro from simpler diagram tools.
Miropricing & limits
Based on 10 users on Business plan at $16/user/mo annual
Where Miro falls short
Free 3-board cap forces paid upgrades immediately
Miro's free tier limits users to 3 active editable boards total. Most teams need a board for each project, sprint, or client — hitting the cap within days of adoption. G2 and Capterra reviews universally identify this as the top complaint. The 3-board cap is deliberately aggressive: it functions as a time-limited trial rather than a genuine free tier.
Performance degrades on boards with thousands of objects
Teams running large workshops (100+ participants, 500+ sticky notes) or complex system architecture diagrams report noticeable lag when manipulating objects, zooming, or panning. The CRDT engine synchronizing thousands of object states across many concurrent users creates CPU overhead that degrades the editing experience on lower-end hardware.
AI credits burn through quickly in workshops
Reddit users in 2025 document burning through a month's AI credits in two afternoon workshops. Miro's AI credits are tied to the number of Business licenses on the account — a team with 10 licenses gets far fewer AI runs than teams with 50 licenses. The opaque credit allocation means teams discover they're out of AI credits mid-workshop.
Cross-teamspace permissions hard to manage
Enterprise Miro deployments with multiple teamspaces (departments, divisions) struggle to manage permissions for contractors, clients, and cross-departmental collaborators. Enterprise reviews consistently cite permission management as confusing and error-prone. Incorrect permissions can expose sensitive boards to unauthorized viewers or accidentally lock out team members.
No true offline mode
Miro requires an active internet connection for all board editing. There is no offline mode — even viewing an existing board requires connectivity. Teams working in low-bandwidth environments (field work, airplanes, poor conference venues) cannot use Miro during workshops. This is a known limitation that Miro has not resolved in its cloud-first architecture.
Key features to replicate
The core feature set any Miro alternative needs — plus what you can improve on.
Infinite canvas rendering engine
A 2D canvas with arbitrary pan (translation) and zoom (scale) that renders objects efficiently at any viewport position. Use HTML5 Canvas or WebGL for rendering — WebGL handles thousands of objects at 60fps while HTML5 Canvas degrades with complex scenes. The viewport is a 2D camera over a world-coordinate space; objects have world positions, and the canvas transforms to the screen. Libraries like Konva.js or Pixi.js provide a foundation, but a Miro-quality canvas requires a custom rendering pipeline.
CRDT-based real-time collaboration
Every object position, size, and property must merge correctly when multiple users edit simultaneously. Yjs with y-websocket handles the real-time CRDT protocol. Each canvas object is a Yjs shared type (YMap for properties). Cursor positions are ephemeral states broadcast via y-awareness. This is the hardest engineering component — expect 6–8 weeks for a reliable multi-user canvas implementation.
Sticky note and object system
Sticky notes (text + color + position + size), rectangles, circles, arrows, and connectors as first-class canvas object types. Each object type has a schema stored in a Yjs YMap. Selection handles, resize handles, and connection points are rendered as overlay SVG elements positioned over the canvas. Bulk selection (lasso) and multi-object operations require spatial indexing (R-tree or k-d tree) for performance.
Freehand drawing and annotation
Smooth freehand drawing using pointer events with Bézier curve fitting. Pressure sensitivity if using a stylus. Drawing strokes stored as SVG path data in Yjs. Perfect Freehand (open-source, MIT) provides excellent stroke smoothing — integrate it for immediate quality. Erase tool requires per-stroke interaction detection.
Template system
Templates are JSON snapshots of a canvas state (objects, positions, sizes, colors) that can be instantiated onto a new board. A template gallery with categories, preview images, and search. Start with 50–100 templates for your target use case (retrospectives, sprint planning, architecture diagrams) rather than competing with Miro's 5,000. Each template instantiation deep-copies the Yjs document structure.
Voting and facilitation widgets
Voting: each sticky note has a vote count, users can cast 1–N votes per session with optional anonymity. Timer: countdown display visible to all participants, triggers notifications at zero. Both are real-time widgets backed by Yjs shared state. The facilitation features differentiate a whiteboard from a simple drawing tool — implement them in week 6–8.
PDF and PNG export at scale
Exporting a large canvas to PDF/PNG requires rendering it at full resolution server-side. Use Puppeteer to navigate to a clean canvas view with all objects visible, then take a full-page screenshot. For very large canvases (10,000+ pixel dimensions), tile the rendering into sections and stitch them together with Sharp. PDF export adds page-layout logic to handle pagination.
Technical architecture
A Miro alternative is a real-time collaborative whiteboard platform combining an infinite canvas rendering engine, a CRDT synchronization layer, and a facilitation feature set. The core engineering challenges are: (1) a canvas renderer that handles thousands of objects at 60fps with smooth pan/zoom, (2) CRDT-based real-time object synchronization across concurrent users, and (3) spatial indexing for performant selection and interaction detection. Excalidraw (MIT) and tldraw provide open-source foundations, but a production-quality infinite canvas requires significant custom engineering.
Canvas rendering engine
HTML5 Canvas + Konva.js, Pixi.js (WebGL), custom WebGL, Excalidraw embed
Recommended: Excalidraw as an embedded component (MIT) for a vertical tool — provides a production-quality infinite canvas with drawing, shapes, and collaboration out of the box. Custom WebGL renderer only for a horizontal Miro replacement requiring custom object types.
CRDT real-time layer
Yjs + y-websocket, Automerge, tldraw's sync engine
Recommended: Yjs + Hocuspocus WebSocket server — most widely deployed CRDT in collaborative tools. Excalidraw uses its own Yjs integration; tldraw has a built-in sync engine.
Persistence and storage
PostgreSQL (Supabase), y-postgresql, MongoDB
Recommended: y-postgresql via Supabase — persist Yjs document snapshots to PostgreSQL. Periodic snapshots (every N operations or on disconnect) allow recovering board state. Store board metadata (name, members, settings) in standard PostgreSQL tables.
Backend API
NestJS, Next.js Route Handlers, Express
Recommended: NestJS — handles board management, team permissions, billing, and serves as the REST API alongside the WebSocket server. Separate the WebSocket sync process from the API process for scalability.
Export pipeline
Puppeteer, Sharp, node-canvas
Recommended: Puppeteer for PNG/PDF export — renders the board in a headless Chrome instance at specified dimensions. Sharp handles image post-processing and stitching for large exports.
Auth and permissions
Supabase Auth, Clerk, NextAuth v5
Recommended: Clerk — handles workspace invitations, guest access (viewer-only links), and org-level permission management. Worth the cost for a multi-tenant whiteboard with external sharing.
Real-time presence
Yjs y-awareness, Supabase Presence, Ably
Recommended: Yjs y-awareness — cursor positions, user names, and selection states broadcast as ephemeral awareness state alongside the CRDT document. No additional infrastructure needed.
Complexity estimate
Complexity 9/10 — the infinite canvas with CRDT multi-user editing is among the hardest frontend engineering challenges. A performant canvas at 10,000+ objects requires a WebGL renderer and a spatial index. Plan for 6–9 months with a team of 3–4. Using Excalidraw as the embedded canvas component drops complexity to 5–6/10 for a vertical tool.
Miro vs building your own
Open-source Miro alternatives
Existing projects you can self-host or use as a starting point. Each has trade-offs.
Excalidraw
120KExcalidraw is an open-source virtual whiteboard (MIT) with a hand-drawn aesthetic. It supports shapes, freehand drawing, text, and real-time collaboration. With 120K+ GitHub stars, it's the most popular open-source canvas tool and is actively developed with regular releases. The Excalidraw component is embeddable in any React application — this is its strongest value proposition for custom builds.
tldraw
41Ktldraw is an open-source infinite canvas framework (tldraw license) that powers a clean, professional-looking whiteboard application. Version 5.0 was released in 2026 with significant performance improvements. tldraw's sync engine handles real-time collaboration. Note: tldraw requires a paid license key for production commercial use — it is NOT fully open source for commercial deployment.
Build vs buy: the real math
6–9 months
Custom build time
$200K–$400K
One-time investment
21+ years for pure replacement at 30 seats; rational only as embedded feature or vertical SaaS
Breakeven vs Miro
At 30 seats on Miro Business, the annual cost is $5,760/yr. A custom build at $200K–$400K breaks even in 35–69 years — the pure replacement case is not compelling at any realistic team size. The only rational Miro alternative strategy is the Excalidraw embed approach: embed Excalidraw (MIT, free) as a whiteboard component in an existing product that already has a paying user base. This costs $20K–$60K for integration and deployment, and provides value through differentiation rather than cost savings. A 'whiteboard for legal teams' embedded in legal matter management software, or a 'design sprint tool for agencies' embedded in a project management platform, creates a competitive moat at a fraction of the full-build cost.
DIY roadmap: build it yourself
This roadmap covers two approaches: (A) building a full Miro alternative from scratch for teams that need complete control, and (B) the faster Excalidraw-embed approach for adding a whiteboard to an existing product. Approach B is recommended for most teams.
Option B: Excalidraw embed (recommended)
3–5 weeks- Install @excalidraw/excalidraw npm package in your Next.js application
- Implement Supabase persistence: save Excalidraw scene JSON on change events
- Set up Yjs + y-websocket for real-time collaboration using Excalidraw's collab API
- Build board management layer: create, name, share boards with workspace members
- Add custom branding: override Excalidraw's default UI elements with your product's design
- Implement board permissions: viewer-only shared links, member access control
Option A: Custom canvas (full Miro alternative)
8–12 weeks- Build canvas rendering engine with Konva.js or Pixi.js for WebGL rendering
- Implement infinite pan/zoom with viewport transformation and world coordinates
- Build object system: sticky notes, shapes, connectors with position/size/color Yjs state
- Integrate Yjs for CRDT multi-user synchronization with Hocuspocus WebSocket server
- Add cursor presence via Yjs y-awareness for live multi-user indicators
- Implement freehand drawing using Perfect Freehand library for smooth strokes
Facilitation features and templates
4–6 weeks- Build voting widget: per-object vote count with anonymous/attributed modes
- Add timer widget: countdown visible to all participants, configurable alarm
- Implement template gallery with 30–50 templates for your target use case
- Build comments system: threaded comments anchored to canvas objects
- Add selection groups and bulk operations (align, distribute, resize together)
- Implement PDF/PNG export via Puppeteer server-side rendering
Workspace management and deployment
3–4 weeks- Build workspace with board library, search, and folder organization
- Implement external sharing with view-only link tokens
- Add Stripe billing for team workspace subscriptions
- Set up Vercel deployment and WebSocket server on Railway or Fly.io
- Performance testing: measure canvas performance at 1,000 and 5,000 objects
Option A (custom canvas) carries significant technical risk — the WebGL renderer performance and CRDT integration have many edge cases. Budget a 40% timeline buffer. Option B (Excalidraw embed) is dramatically lower risk and delivers 80% of Miro's value in a fraction of the time. Choose Option A only if Excalidraw's hand-drawn aesthetic or limited object types are dealbreakers for your use case.
Features you can't get from Miro
This is where a custom build pulls ahead — features impossible or impractical on a shared platform.
Embedded whiteboard in project management or CRM tools
Embed Excalidraw as a whiteboard tab in your existing project management, design tool, or CRM product. Context-aware boards that pre-populate with data from the parent application (project tasks on a sprint board, deal stages on a sales flowchart). Miro requires leaving the parent application; an embedded whiteboard keeps context in one place.
Facilitation AI that generates workshop agendas
Use Claude to generate a custom workshop agenda, pre-populate a board with relevant templates and sticky note categories, and time-box activities based on team size and objectives. Miro's AI creates diagrams but doesn't design the workshop structure. An AI facilitator that sets up the board before the session dramatically reduces workshop preparation time.
Persistent spatial organization of project knowledge
A whiteboard where objects are linked to database records (tasks, documents, decisions) and update in real-time as the underlying data changes. Miro boards are static snapshots — a custom build can show live task status on a kanban board diagram or live metric values on a system architecture diagram.
Workshop recording with synchronized video and board state
Record the workshop session (screen + audio) and synchronize the recording to the board state timeline — scrubbing the recording shows the board as it looked at that moment. Miro has no session recording. This creates a complete workshop artifact (video + board + decisions) that teams can review asynchronously.
Offline-capable whiteboard with sync on reconnect
Use y-indexeddb to persist Yjs state in browser IndexedDB so boards load and edit without connectivity. Changes accumulated offline sync automatically on reconnect. Miro has no offline mode. For teams that run workshops in low-connectivity environments (remote offices, conferences, field locations), offline capability is a genuine differentiator.
Who should build a custom Miro
Product and SaaS companies embedding whiteboard into existing tools
Adding an Excalidraw-based whiteboard to an existing product (project management, design tool, CRM) costs $20K–$60K and differentiates the product without replacing Miro. Teams stay in context — the whiteboard is a feature of your product, not a separate SaaS subscription. This is the only financially rational Miro alternative strategy for most companies.
Enterprise teams frustrated by the 3-board free cap
Miro's 3-board cap converts free users to paid almost immediately. Organizations evaluating Miro for a 100+ seat deployment face $16/user/mo Business — $19,200/yr for 100 seats. At this scale, a custom Excalidraw-based whiteboard embedded in internal tools costs $30K–$80K and eliminates per-seat scaling costs permanently.
Facilitation companies building workshop tooling
Professional facilitators and workshop design companies that use Miro to run paid workshops can build a branded whiteboard tool with custom facilitation features (AI agenda generation, custom timer sounds, branded voting widgets) that differentiate their service offering. Charging clients $1,000–5,000 per workshop session makes a $100K–$200K custom build ROI-positive in under 6 months.
Skip the DIY — let RapidDev build it
Everything above is doable — but it takes months of full-time work. We build custom Miro alternatives using AI-accelerated development, delivering in weeks what used to take quarters.
Discovery call (free)
30 minWe map your exact requirements: which Miro features you need, what custom features to add, your users, integrations, and compliance needs. You get a detailed scope document and fixed-price quote within 48 hours.
AI-accelerated build
6–9 monthsOur engineers use Claude Code, Lovable, and custom AI tooling to build 3–5x faster than traditional development. You see progress in a staging environment every week — not a black box for months.
Launch + handoff
1 weekWe deploy to your infrastructure, transfer the GitHub repo, set up CI/CD, and walk your team through the codebase. You own 100% of the source code — no vendor lock-in, no recurring platform fees.
What you get
Timeline
6–9 months
Investment
$200K–$400K
vs Miro
ROI in 21+ years for pure replacement at 30 seats; rational only as embedded feature or vertical SaaS
30-min call. Fixed-price quote within 48 hours. No commitment.
Frequently asked questions
How much does it cost to build a Miro alternative?
A full Miro alternative with custom infinite canvas costs $200K–$400K and takes 6–9 months. The Excalidraw-embed approach (embedding Excalidraw as a React component in an existing product) costs $20K–$60K and takes 3–5 weeks. For most use cases, the Excalidraw embed is the rational choice — it provides 80% of Miro's value at 10–20% of the build cost.
How long does it take to build a Miro clone?
6–9 months for a full Miro alternative with a custom canvas, CRDT collaboration, facilitation tools, and workspace management. 3–5 weeks for an Excalidraw-based embedded whiteboard. The custom canvas renderer and CRDT integration are the primary time drivers — each can consume more than the initial estimate if edge cases (large canvases, high concurrent user counts) are not anticipated.
Are there open-source Miro alternatives?
Two strong options: Excalidraw (~120K GitHub stars, MIT) is the most popular open-source canvas tool — free for commercial use, embeddable as a React component, with real-time collaboration. tldraw (~41K stars) has the most polished UX but requires a paid license for production commercial use — verify terms before building on it.
Can RapidDev build a custom Miro alternative?
Yes — RapidDev has built 600+ applications including real-time collaboration tools, canvas-based editors, and embedded component libraries. We typically recommend the Excalidraw embed approach for new builds. Visit rapidevelopers.com/contact for a free consultation on your specific whiteboard requirements.
Why is Miro's 3-board free cap so aggressive?
The 3-board free cap is Miro's most effective paid conversion mechanism — teams hit it within days of adoption, typically before they've had time to evaluate alternatives. This creates urgency to upgrade before users can realistically assess the $8–16/user/mo cost. The limit was deliberately set at 3 rather than a higher number because 3 boards covers an initial evaluation period but not ongoing team use.
Should I use Excalidraw or tldraw as a foundation?
Excalidraw (MIT license, ~120K stars) is the recommended choice — fully free for commercial use, actively maintained, embeddable as a React component, and has a proven production deployment at scale. tldraw has superior UX but requires a paid production license that is not open source. For a commercial product, Excalidraw's MIT license provides freedom from licensing risk that tldraw cannot guarantee.
Can I export Miro boards to a custom build?
Miro provides JSON export for board content (shapes, sticky notes, text, connections) via the Miro API. Images and media embedded in boards require separate download. A migration script can parse the Miro JSON export and convert it to the Excalidraw JSON format (or your custom board format). The visual fidelity of migrated boards will be approximate — exact styling and fonts may not transfer.
What is the real cost of Miro at enterprise scale?
At 100 seats on Business ($16/user/mo), Miro costs $19,200/yr. Enterprise pricing typically ranges from $20–28/user/mo (CloudNuro), so a 100-seat Enterprise deployment can cost $24,000–33,600/yr. At this scale, a custom Excalidraw-based whiteboard embedded in internal tools ($30K–80K build cost) breaks even in 1–4 years while adding customization control and no per-seat scaling cost.
We'll build your Miro
- Delivered in 6–9 months
- You own 100% of the code
- No per-seat fees, ever
30-min call. No commitment.