CoralDoc alpha docker compose up

---
hosting: self-hosted · cloud (soon)
status: multi-tenant · alpha
---

The knowledge base your engineers actually want to use

Real Markdown, technical rendering that works, and full ownership of your content — with the collaboration controls teams need. Your docs live in Git, work with AI, and render like they were built by engineers, not pasted from Word.

Bring your Obsidian vault →
runbooks/deploy-rollback.md — Monaco
--- title: Deploy rollback runbook tags: [runbook, sre, cloud-run] ---   # Deploy rollback runbook   If a release degrades p99 latency, roll back to the previous revision. See [[oncall-guide]].   ## Escalation flow   ```mermaid flowchart LR Alert --> Triage --> Rollback ```   ```bash gcloud run services update-traffic api \ --to-revisions=api-00041=100 ```
live preview 2 comments · ⭐ starred

Deploy rollback runbook

#runbook#sre#cloud-run

If a release degrades p99 latency, roll back to the previous revision. See oncall-guide.

Escalation flow

Alert Triage Rollback 
gcloud run services update-traffic api \
  --to-revisions=api-00041=100

Not a watered-down Markdown dialect. The file on the left is a real .md — open it in VS Code, Obsidian, vim, or your CI pipeline.

own: everything

Content you own

Plain .md and .canvas files with YAML frontmatter. No proprietary database. No export tax. Back up, grep, and migrate with tools you already have.

built_for: technical content

Rendering that works

Mermaid, DBML, Scalar/OpenAPI, in-browser PDF embeds, and syntax highlighting for 100+ languages — with a plugin SDK for PlantUML, GraphQL, or custom fence types.

ai: native

AI-native by design

Markdown is what LLMs read and write best. Your docs are instantly usable by RAG pipelines and coding assistants — plus an integrated AI Writer and REST API for agentic workflows.

section: features

Enterprise collaboration, file-first

Everything teams expect from a modern knowledge base — stored as files you control, not rows in a vendor's database.

editors/

Three editor modes

Monaco (VS Code's engine), WYSIWYG (Tiptap), or plain textarea — switch anytime, with side-by-side live preview and draft recovery when the network drops.

storage/

Store anywhere, mixed per project

Local disk, Git with auto-commit, GitHub, Azure Blob, or AWS S3 — drafts on disk, engineering docs in Git, compliance archives in S3. Simultaneously.

collab/

Comments, mentions, backlinks

Line-anchored comments with threaded replies, @mentions, tags, favorites, and a "linked from" panel — stored as Markdown files alongside your pages.

access/

Multi-tenant RBAC that scales

Tenant isolation from day one. Groups, custom roles, and scoped grants at project, folder, and page level — hierarchical projects organize domains without collapsing access control.

history/

Git-backed audit trail

Auto-commit on every save with author attribution. Browse revisions, diff side-by-side, and restore — docs can colocate in the same repo as the systems they describe.

canvas/

Native JSON Canvas

Create and edit .canvas boards in the browser — nodes, edges, groups, pan and zoom. The same open format Obsidian uses, not view-only.

section: structure

Knowledge structured the way your repos already are

Large domains rarely live in a single Git repo — so why should their docs live in a single wiki space? Model each domain — Platform, Payments, Mobile — as a top-level project holding cross-cutting ADRs and runbooks, with sub-projects per repository underneath. Each sub-project is a full content root — its own storage provider, path, comments, and permissions. The parent is organizational glue, not a forced merge of every repo into one tree.

And a domain isn't a special type: it's just a project that happens to have children. It holds its own pages, has its own provider and grants, and any project can become a parent later — or stay flat. That's the difference between "a wiki space that grew forever" and a navigable hierarchy that matches your monorepo or multi-repo estate.

A project per domain. A sub-project per repo. →

tenant: acme/

├── Platform/ ← ADRs, cross-cutting runbooks

│   ├── api-service/ → git: services/api

│   └── web-app/ → git: apps/web

├── Payments/ ← PCI docs, payment flows

│   ├── billing-worker/ → git: workers/billing

│   └── invoicing/ → git: services/invoicing

└── handbook/ ← flat is fine too

## every project — parent or child:

own pages · own storage provider · own permissions · own comments

A domain is just a project with children — no special type. Grants stay per project; hierarchy never collapses access control.

section: diagrams as code

Design your database in text, not a drawing tool

Drag-and-drop diagram tools produce images: no context, no history, unsearchable, and unreadable to your AI tooling. A PNG of last year's schema tells you nothing about what changed or why.

In CoralDoc, diagrams are code. Describe a schema in DBML or a flow in Mermaid inside an ordinary code fence, and it renders as a live, theme-aware diagram — no plugins, no embeds. Because it's just text in the page:

  • + it's versioned and diffable — schema changes show up line by line in Git history
  • + it's greppable — find every diagram that touches the orders table
  • + LLMs and coding assistants can read, critique, and generate it directly
  • + anyone can edit it in a review, without hunting for the original .drawio file

Sequence, flowchart, ERD, state, Gantt via Mermaid; entity design via DBML — and a plugin SDK when you need PlantUML, GraphQL schemas, or your own fence type.

architecture/orders-schema.md ``` dbml
```dbml Table orders { id uuid [pk] customer_id uuid [ref: > customers.id] status order_status } Table customers { id uuid [pk] email text [unique] } ```

renders as ↓

orders id · uuid 🔑 customer_id · uuid customers id · uuid 🔑 email · text ◆ * 1

Change a column, see the diff, re-render. Try that with a screenshot.

section: migration

Review the diff

Confluence stores your knowledge in Atlassian's database. CoralDoc stores it in files you already know how to back up, search, and feed to AI.

knowledge-base.patch −9 +9
@@ your-knowledge-base @@ migrate: confluence → coraldoc
-proprietary rich-text JSON in Atlassian's database
+plain Markdown + JSON Canvas files with YAML frontmatter
-diagrams: screenshots, or plugins like Gliffy
+native Mermaid, DBML, and editable canvas — theme-aware
-API docs live in a separate tool
+Scalar/OpenAPI rendered inline from code fences
-export for LLM consumption is a conversion project
+AI-native: Markdown is what LLMs read and write
-page history locked in; export is painful
+in-app diff/restore + Git auto-commit with attribution
-one space per team that sprawls or fragments
+hierarchical projects: domain root + repo sub-projects, each with its own storage
-space and page restrictions
+tenant RBAC + groups + project/folder/page scoped grants
-Data Center licensing, or vendor-hosted cloud
+self-hosted with Docker, on your infrastructure
-per-seat pricing that scales with headcount
+no per-seat tax — your knowledge base shouldn't cost more because your team grew

Already on Confluence? CoralDoc can coexist — start with one team's engineering docs. Migration is copying Markdown files, not a vendor migration project.

section: obsidian

Keep Obsidian for thinking.
Add CoralDoc for sharing.

Point CoralDoc at a folder with .obsidian/ and it just works. Wikilinks resolve, callouts render, PDF embeds open in-page, and your team can create and edit canvas boards in the browser. Edit locally in Obsidian; collaborate centrally in CoralDoc. Same files, same wikilinks, same canvas — now with permissions and your whole team.

Bring your vault. Add your team. Keep your files.

~/vaults/team-knowledge/

├── .obsidian/ ← auto-detected

├── architecture/

│   ├── adr-014-event-pipeline.md

│   └── system-map.canvas ← editable in browser

├── runbooks/

│   ├── deploy-rollback.md

│   └── _comments/ ← comments are files too

└── specs/

    └── vendor-api-v2.pdf ← ![[embeds in-page]]

$ git log --oneline -- docs/

a3f91c2 Update ADR-014 decision status · CoralDoc web · mei

9d4e77b Fix rollback steps in runbook · VS Code · rob

71c0aa8 Refactor API docs alongside code · Cursor · sam

c58d210 Draft DBML schema for orders svc · AI Writer · agent

2b7f4e9 Typo sweep across runbooks · vim · priya

One doc set, five editors, zero sync layer — it's just Git.

section: your editor

Your editor is already a CoralDoc client

Because every page is a plain .md file in Git, there's no plugin to install and nothing to sync. Open docs in VS Code, Cursor, JetBrains Rider, or vim, edit next to the code they describe, and push — changes show up in CoralDoc with full attribution and version history.

It cuts the other way too: coding assistants like Cursor and Copilot read your runbooks and ADRs straight from the repo, and AI agents can create and update pages through the REST API. Docs your tools can actually use.

section: quickstart

Writing in five minutes

  1. 01 Deploy with Docker — single image, or Compose, Aspire, ACA, ECS, on-prem.
  2. 02 Create a tenant and invite your team, or use the demo login.
  3. 03 Point a project at an existing Git repo or Obsidian vault — or nest repo sub-projects under a domain root.
  4. 04 Write a page with Mermaid, code, an OpenAPI block, and a PDF embed.
  5. 05 Create a canvas, leave a comment, star a page — then compare it to your current knowledge base.
zsh

$ docker compose up

coraldoc | Now listening on: http://localhost:9000

coraldoc | Tenant "demo" ready — start writing.

No per-seat licensing. No new SaaS line item. Runs on a laptop. Docker image coming soon.

Prefer zero ops?

Cloud hosting at app.coraldoc.com — same platform, same file ownership.

coming soon → join waitlist
"Your knowledge base shouldn't cost more because your team grew. Your docs shouldn't be held hostage because you stopped paying."
Join the early waitlist

section: roadmap

Coming soon

CoralDoc is in alpha and actively developed. Here's what's shipping next:

  • [ ]

    Public Docker image

    One command to a running knowledge base — docker compose up and you're writing.

  • [ ]

    Cloud hosting — app.coraldoc.com

    Same platform, zero ops. Your content stays plain files you can take with you.

  • [ ]

    Microsoft & Google SSO

    Joining GitHub SSO and email/password sign-in.

  • [ ]

    Confluence-to-Markdown converter

    Make leaving the proprietary database a file copy, not a migration project.

list: early access

Join the early waitlist

Be first to hear when CoralDoc launches, plus occasional product updates along the way. No spam.