# Collaborative Markdown Editing Alternatives to HackMD

## Introduction & Key Requirements

Teams seeking to collaboratively author Markdown (and MDX) documents have many tools beyond HackMD. The ideal solution should support:

* **Seamless Collaboration:** Multiple users editing content (real-time or asynchronous) with comments/annotations for feedback.
* **Static Site Publishing:** Easy export or direct integration with static site generators (e.g. Docusaurus, Next.js), preserving relative links.
* **Robust APIs & Integration:** An API without restrictive call limits, plus ability to integrate or script with tools like Airtable (as a content source) and Slack (notifications).
* **Git Compatibility:** Option to use Git/GitHub for version control, so even a semi-technical team can leverage branching, history, and reviews.
* **MDX & Embeds:** Support for MDX or at least insertion of custom HTML (like YouTube iframes) in docs.
* **Frontmatter & Automation:** Handling YAML/JSON frontmatter metadata (titles, tags, etc.), possibly auto-generating or managing it (with AI assistance if available).
* **Pricing:** Reasonable pricing or free tiers for small teams, with higher plans if needed.

Below we compare several platforms that meet these criteria, with pros, cons, pricing, and feature highlights.

## HedgeDoc (Open-Source HackMD Fork)

**Overview:** HedgeDoc (formerly CodiMD) is a **self-hosted, real-time collaborative Markdown editor** very similar to HackMD. Users edit notes in a web interface and see each other’s changes instantly. It’s open source (AGPL license) and you can host it on your own server or cloud instance.

**Pros:**

* **Real-Time Collaboration:** Multiple users can edit simultaneously with live updates (just like HackMD). Great for team note-taking, diagrams, even slide decks.
* **Open Source & Self-Hosted:** No per-user fees or API limits – you control the server and data. HedgeDoc provides Docker images and install guides for easy setup.
* **Markdown Features:** Supports GitHub-flavored Markdown plus extensions (code blocks, math, Mermaid diagrams, slide mode, etc.). Can embed iframes or media when allowed (configurable).
* **Export Options:** Notes can be downloaded as Markdown, PDF, HTML, etc. There’s integration to export content to GitHub Gists and other services. This makes it possible to pull notes into other workflows.
* **Basic Versioning:** Each note has revision history and can be connected to GitHub for OAuth login or backups. (HackMD’s GitHub integration for syncing to repos is not fully in HedgeDoc, but Gist export works.)

**Cons:**

* **Self-Management Required:** You must host and maintain the server (updates, security, uptime). This adds overhead compared to a cloud service.
* **Limited Static Site Integration:** HedgeDoc isn’t designed as a static site CMS. Exported Markdown may need manual handling. Relative links between notes aren’t maintained automatically – you’d need to ensure the same folder structure when exporting notes to files. There’s no native frontmatter support (YAML in a note is mostly ignored except for HackMD-specific configs).
* **No Native Airtable/Slack Integration:** Out-of-the-box, it doesn’t connect to Slack or Airtable. You could script via the HedgeDoc API (it offers a REST API for creating or fetching notes) but you’d need to build that integration.
* **Comments/Workflow:** No built-in commenting system on the notes (collaboration is purely live editing). It’s best for drafting content together, not for formal review cycles or publishing pipelines.

**Pricing:**

* **Free & Open-Source:** No license cost. You provide the hosting. For a small team, running HedgeDoc on a \$5–\$20/month cloud instance could suffice. The only “cost” is your time maintaining it. (There is no paid plan, though some hosted instances exist run by communities.)

**Use Case Fit:** HedgeDoc is excellent if you want a **HackMD replacement with full control**. Teams can collaborate in real time without platform limits. It’s less ideal if you need tight Git or static site integration – you would export notes and manually add frontmatter or use scripts to integrate into Docusaurus/Next. If real-time editing and open source are top priorities, HedgeDoc is a leading choice.

## Outline (*Open-Source Team Wiki*)

**Overview:** Outline is an open-source, web-based team knowledge base and wiki with a **WYSIWYG editor that stores content in Markdown** format. It’s like an internal wiki (similar to Notion or Confluence) but **Markdown-native**. Outline supports collaborative editing (not true simultaneous typing, but documents update for all users quickly) and includes rich embed widgets and a Slack integration.

**Pros:**

* **Markdown at the Core:** All pages are saved as Markdown and can be imported/exported as Markdown files. This makes migrating to a static site generator easier – your content is already in MD.
* **Easy Editing UI:** Users don’t need to know Markdown syntax (there’s a rich editor with formatting toolbar, slash commands, etc.), but they *can* use Markdown shortcuts while typing. This lowers the barrier for non-technical authors.
* **Slack Integration:** Excellent Slack integration is a highlight. You can search the wiki from Slack via `/outline` commands, and **notifications of new or updated docs can be posted to Slack** automatically. It keeps the team in sync.
* **Comments & Editing Workflow:** Outline recently introduced a basic commenting feature on pages (allowing discussions on drafts). It also supports publishing/unpublishing pages – new pages can be in draft until “published,” which adds a slight review workflow (although some find this a bit clunky).
* **Integrations & Embeds:** Outline supports embedding content from popular services (e.g. YouTube, Figma, etc.) via link previews. It has an API covering all functionality, meaning you can script or integrate it with other tools. (For example, you could use the API to sync certain pages to a Git repo or to Airtable, though this would require development.)
* **Self-Hosted or Cloud:** You can self-host Outline for free (source available on GitHub), or use Outline’s hosted cloud service (with a free trial) if you prefer not to manage infrastructure.

**Cons:**

* **Publishing to Static Sites Not Native:** Outline is designed as a live web app/wiki. There’s no one-click export of the entire space into a static site. If you want to publish via Docusaurus/Next, you’d likely have to export pages (Outline can export individual pages to Markdown) and commit them to Git. Relative links between pages in Outline might not directly translate to correct relative paths in a static site, so you’d need a conversion process.
* **Not Real-Time Co-editing:** Only one person can actively edit a document at a time (others see a lock or read-only mode). It’s collaborative in that everyone has access and can edit sequentially, but not concurrent character-by-character editing like HackMD.
* **Requires Some Setup (if self-hosted):** Outline runs on Node/PostgreSQL. Setting that up and managing updates may be non-trivial for some teams. The cloud version simplifies this but is paid after the trial.
* **Limited Frontmatter Control:** Metadata like titles, slugs, and tags exist in Outline’s database, but if exporting to MD files for a site generator, you’d have to insert that metadata as frontmatter manually. Outline doesn’t automatically generate static-site frontmatter.
* **Pricing:** The open-source edition is free. The hosted Outline Inc. service requires payment after a 30-day trial. They have per-user pricing (e.g. \~\$10/user/month range) for the SaaS. If you have the ability, self-hosting is the cost-effective option.

**Pricing:**

* **Self-Hosted:** Free apart from server costs. Many teams run Outline on their own domain.
* **Cloud Hosted:** Paid (post-trial). For example, Outline’s cloud plan was around \$5–\$10 per user per month (and they allow unlimited read-only guests). It’s free for 30 days to try. *Check Outline’s site for up-to-date pricing.*

**Use Case Fit:** Outline is great as an **internal wiki or knowledge base** with a friendly UI that still uses Markdown under the hood. If your team wants a Notion-like experience but needs Markdown export, Outline delivers. It’s less suited as a direct static site source (without building an export pipeline). However, some teams use Outline for drafting and internal collaboration, then export to Markdown for the static site – this is viable if the extra step is acceptable. The strong Slack integration is a plus for keeping everyone informed.

## GitBook (Cloud Documentation Platform)

**Overview:** GitBook is a popular documentation platform that allows teams to write content in Markdown (or using a block editor) and publish it as a hosted site. The new GitBook is cloud-based with real-time collaboration, a rich editor, and **built-in version control and review workflows**. It can also sync with a Git repo if needed. GitBook is well-suited for product docs, knowledge bases, and internal wikis, and it has a feature-rich API and integrations.

**Pros:**

* **User-Friendly Editor with Markdown Support:** GitBook provides a polished editing experience – you can write in Markdown or use the WYSIWYG interface. In fact, GitBook’s custom editor works with Markdown syntax behind the scenes. Authors can use Markdown or even HTML in their pages, but non-technical users can just click formatting buttons.
* **Real-Time Collaboration & Comments:** Multiple team members can edit simultaneously, and **inline comments** and discussion threads are supported for feedback. You can tag users in comments (`@user`) and resolve comment threads when done. This is great for editorial workflows.
* **Version History and Change Requests:** GitBook keeps a version history of pages and also has a “Change Requests” feature (similar to pull requests). Team members can propose changes which others review and approve within GitBook’s UI. This provides **workflow control without needing Git** expertise.
* **Git Integration (Sync):** GitBook can integrate with GitHub or GitLab – you can sync content to a Git repository if you want the files in Git. This is optional but useful if you have developers who prefer editing in code or need to store docs alongside code.
* **Publishing & Static Site Generator Support:** By default, GitBook publishes your content on their platform (with custom domain support on paid plans). While it’s not designed to export into another static site generator, the Git sync means you could have the Markdown in a repo that powers Docusaurus or Next.js. (GitBook itself outputs a documentation website, so many teams just use that directly rather than separate SSG.) If you do need to migrate, you can export your space as a collection of Markdown files. Relative links generally remain intact if the structure is consistent.
* **Embeds and MDX-Like Extensions:** GitBook pages can include rich embeds. Pasting a YouTube or Loom link, for example, auto-generates an embed player. You can also embed code snippets, diagrams, and API reference components. While not exactly MDX, it covers many use cases for custom content.
* **API and Integrations:** GitBook offers a REST API and webhooks. Notably, it integrates with Slack (notifications for changes or comments), and also with platforms like Zendesk, Google Analytics, etc. This means you can script things like syncing content to Airtable via the API or get Slack alerts when docs are updated.
* **AI Assistance:** Uniquely, GitBook has introduced **AI-powered features**. It includes an “AI Assistant” (called GitBook AI or Lens) that can answer questions from your documentation and help writers generate or improve content. For example, you can ask it to summarize a page or draft an overview. This could potentially help generate frontmatter elements like summaries or descriptions automatically.

**Cons:**

* **Proprietary Format Lock-In (if not using Git sync):** GitBook stores content in its own system. If you don’t use the GitHub sync feature, you’re reliant on their export to get Markdown out. The exported Markdown may need tweaks (GitBook uses some extensions). If linking pages, the links might export as full URLs (e.g., to the GitBook site) rather than relative paths, requiring a find/replace. Using Git sync can mitigate this by keeping sources in your format.
* **Limited Customization of Output:** GitBook’s own published site has a certain theme and structure. If you want full control (as you would with Docusaurus/Next), GitBook might be limiting unless you export the content. It doesn’t support custom React components the way MDX does – you can’t drop arbitrary JSX; you’re limited to their embed options and HTML snippets.
* **Cost for Full Features:** GitBook has a free tier (usually for open-source or small teams, often limited to a few users with public docs). For private docs or larger teams, the **paid plans** cost around \$6–15 per user/month depending on tier. Some features like advanced permissions, Slack integration, and AI assistant require the Pro or higher plans. Also, the free plan content is public by default, meaning you’d pay to keep docs private.
* **No Native Airtable Integration:** There isn’t a built-in Airtable connector. You would have to use the API to push or pull data. For example, you could use GitBook’s Content API to fetch pages and then update Airtable records, but that’s custom work.
* **Frontmatter Handling:** GitBook doesn’t expose a YAML frontmatter on pages. Metadata like title, description, and slug are managed in the GUI. If you export pages for a static site, you’d need to insert that metadata into a frontmatter block. There’s no automatic AI frontmatter generation specifically (though you could manually use the AI feature to create summaries).

**Pricing:**

* **Free Tier:** GitBook offers free usage for small teams or open-source projects. Free tier supports a few “core users” (contributors) – e.g., up to 3 – and unlimited read-only viewers. However, private spaces on free tier are limited.
* **Paid Plans:** Common plans are **Standard/Plus** (~~\$8/user/mo) and **Pro** (~~\$15/user/mo). Pro unlocks more integrations (Slack, Teams), Git sync, and the AI features. Enterprise plans exist for SSO and advanced security. *Always check current pricing, as they update tiers.*

**Use Case Fit:** GitBook is an **all-in-one solution**: an editing platform, review workflow, and publishing service. It’s excellent if you want to collaborate on markdown-based docs with a polished UI and not worry about hosting your own site. For teams already using static site generators, GitBook can still be used for authoring and then synced/exported, but that adds complexity. If real-time collaboration, commenting, and a managed platform are priorities – and budget allows – GitBook is a strong choice. The built-in version control and **sync with GitHub/GitLab** are especially useful to bridge tech and non-tech users.

## Notion (Collaborative Documents with Markdown Export)

**Overview:** Notion is a widely-used all-in-one workspace for notes, docs, wikis, and project management. While Notion is not a Markdown-native editor, it can **export content to Markdown** and has an API that developers can use. Teams love Notion for its real-time collaboration, inline comments, and databases. It could serve as a content authoring tool where the source of truth is in Notion, and then you export or sync to Markdown for static site generation.

**Pros:**

* **Excellent Collaboration & UX:** Notion offers real-time multi-user editing with no lag. Rich commenting and discussion features are built in – you can highlight text and leave comments or assign tasks. It’s very user-friendly for non-technical users, with a drag-and-drop WYSIWYG interface, slash commands, and many templates.
* **Powerful Databases (Tables):** Notion’s databases can act like an Airtable – you can create a table for your docs with fields (status, author, tags, etc.). This can effectively manage frontmatter data *inside* Notion (each page can have custom properties). The database can be the source of truth for metadata, which is helpful if integrating with a static site pipeline (via the API, you could pull these properties into frontmatter).
* **Markdown Export & Compatibility:** Any Notion page (that isn’t a database itself) can be **exported as Markdown**. The export includes sub-pages as nested folders. This means you can write in Notion, then export to get .md files for your static site. Notion also preserves attachments (images come out as files) and will try to preserve relative links for sub-pages (though in practice, some link fixing may be needed).
* **Notion API:** The Notion API allows programmatic access to content. You can fetch page content (as structured blocks, which can be converted to Markdown) and watch for changes. For example, using the API (or community tools like `notion-to-md`), you could automate syncing of Notion pages to your Git repository. This addresses the 2000 API calls/month limit of HackMD – Notion’s API is free to use (with certain rate limits, but generous for moderate use).
* **Slack Integration:** Notion has deep Slack integration. You can receive Slack notifications when someone mentions you or edits certain pages, and even send Slack messages into Notion (creating pages/tasks from Slack). This makes it easy to keep the team notified when documentation is updated.
* **Notion AI:** Notion has an AI feature (optional add-on) that can help generate summaries, brainstorm content, or extract action items from text. This could be used to auto-generate a summary or keywords for a document (which you could paste into a frontmatter field). The AI is quite handy for speeding up writing tasks or metadata generation. (Notion AI is free in some paid plans like Business, or as a separate subscription in others.)
* **Free for Small Teams:** Notion’s Personal plan is free and pretty unlimited now (no block limit). For team collaboration, the free plan allows up to 10 guests which can work for a small team, and unlimited members if the workspace is public. It’s a low-cost way to start before scaling up.

**Cons:**

* **Not Markdown Native:** Notion is a proprietary content format (block-based). The **Markdown export can sometimes be messy**. For example, Notion will export a page’s content as a .md file, but complex layouts (columns, toggles) might turn into HTML in the Markdown. Internal links between Notion pages export as just the text of the link (not automatically the correct .md filename link). You often need to manually adjust links to ensure they point to the right relative path in your static site.
* **No Frontmatter on Export:** Exported Markdown files from Notion do not include YAML frontmatter. You have to add that later (perhaps using the Notion page properties). This means extra processing to integrate with static site generators that rely on frontmatter (title, date, etc.).
* **No Git Integration:** Notion doesn’t interface with Git or GitHub. Any syncing to a git repo must be done via external scripts or tools (using the API or export files). Unlike some other tools, there’s no one-click “commit to GitHub” capability.
* **API Complexity:** The Notion API returns data as JSON blocks, not Markdown. So using it requires transforming those blocks into MD or HTML. Libraries like `notion-to-md` exist to do this conversion. It’s an extra layer of complexity to set up an integration pipeline (though quite doable). Also, the API doesn’t notify you of changes in real-time; you’d poll or use a third-party service for change detection.
* **Performance on Very Large Docs:** Notion pages that are extremely large (e.g., dozens of MB or thousands of blocks) can get slow. If your documentation is very lengthy, it might not be as snappy as editing in a code editor. Breaking content into smaller pages (as one would for a static site) mitigates this.
* **Cost for Advanced Use:** While Notion is generous on free usage, for advanced team features (like unlimited version history, SAML SSO, etc.), you’d need the Team or Business paid plans. Team is around \$8/user/month and Business \$15/user/month. Notion AI, as of 2025, is included in Business plans but not in the Free/Plus (except as a limited trial). So budget for those if needed.

**Pricing:**

* **Free Plan:** Unlimited pages and blocks for individuals or small groups. You can share with up to 10 guests for free, which some teams use as a workaround for a small doc project. This plan includes the API.
* **Plus Plan:** \~\$8 per user/month – allows unlimited members (not just guests) and adds 30-day version history. Good for small teams needing collaboration.
* **Business Plan:** \~\$15 per user/month – adds advanced permissions, 90-day history, and included Notion AI. Necessary if you want built-in AI assistance at scale or private team spaces with many members.
* There are discounts for nonprofits or education, and an Enterprise tier for large orgs.

**Use Case Fit:** Notion shines for **collaborative drafting and knowledge management**. If your team is already comfortable with Notion for specs or notes, extending it to documentation can leverage that familiarity. It’s arguably the best for mixed technical/non-technical collaboration due to its ease of use. For publishing, however, you’ll need to establish an export or sync process to your static site. This could be as simple as regular manual exports or as complex as an automated Git commit via the API. Notion is less direct than a Git-based CMS for static site pipelines, but it offers an unparalleled editing experience and the flexibility of a database (imagine Airtable-like functionality) as your content hub. Many teams use Notion as an editorial environment, then push the content to a site – given its strengths in comments, tasks, and real-time editing, it’s a compelling choice. The **Slack integration** and database automations make it even easier to fit into your workflow.

## Git-Based CMS Solutions (Netlify CMS and TinaCMS)

Using a **Git-backed CMS** means content is stored as Markdown (or MDX) files in a Git repository, but editors get a friendly interface to create and modify those files. This approach inherently works well with static site generators and preserves relative links (files live in a folder structure). Two leading tools in this category are **Decap CMS (formerly Netlify CMS)** and **TinaCMS**. Both are open-source and support GitHub/GitLab integration, but they have different strengths.

### Decap CMS (Netlify CMS)

**Overview:** Decap CMS (originally Netlify CMS) is an **open-source CMS for static sites**. It’s essentially a single-page app that you embed in your site (often at `/admin`) which lets authorized users edit Markdown/YAML content in your Git repo via a nice UI. Every change goes through Git – either committing directly to a branch or via pull requests. It’s free and **extremely flexible**, since it works with any static generator.

**Pros:**

* **Direct Git Storage:** Content remains as flat Markdown files with frontmatter in your GitHub (or GitLab/Bitbucket) repo. **Each edit is a Git commit**, preserving history and leveraging Git’s robustness. You can even require edits to go to a draft branch and be reviewed via PR. This means your static site build always has up-to-date Markdown, and relative links are preserved naturally by the file structure.
* **Static Site Integration:** Designed for static site generators – it doesn’t do the building, it just manages files. So it works with Docusaurus, Next.js (MDX), Hugo, Jekyll, etc. Because the CMS can live alongside your site, you can have live previews of how the content will look. When content is saved (committed), your CI (Netlify, Vercel, etc.) can auto-rebuild the site. This makes publishing to the live site seamless.
* **Frontmatter & Structured Fields:** You configure collections and fields in Decap CMS. For example, a “Docs” collection with fields for title, description, tags, etc. The CMS presents a form for those fields, and it will generate or update the YAML frontmatter for you. This helps non-technical users edit metadata without touching raw YAML. You can even use **hidden fields** or **generated fields** (with custom widgets) to populate frontmatter (e.g., auto-set a date or use AI via a custom widget to suggest a summary).
* **MDX and Custom Widgets:** Decap CMS supports editing Markdown by default and you can extend it to handle MDX. There are community plugins (e.g., a widget for MDX content). You can also write custom widgets in React – for instance, an embed picker for YouTube that inserts the appropriate embed code. This makes it highly extensible.
* **No User Limits / Pricing:** It’s free, open-source. You can self-host the backend (Netlify CMS can use GitHub’s API directly via OAuth, or Netlify’s Identity service). There’s no limit on number of users or API calls aside from your Git provider’s normal rate limits. For example, using GitHub’s API token, you get a high allowance of calls per hour, and normal usage of a CMS won’t hit those. This is a **huge advantage over HackMD’s 2000 calls/month limit**.
* **Community & Identity Options:** Originally built by Netlify, it has a community behind it. If you host on Netlify, you can use Netlify Identity service to manage CMS login without each user having a GitHub account. Alternatively, a feature called **Git Gateway** allows email/password auth and uses a proxy to commit to GitHub on behalf of users. This is useful if not everyone is comfortable with GitHub accounts.
* **Slack and Airtable Integration:** While Decap CMS doesn’t have native Slack/Airtable plugins out-of-the-box, you can integrate at the process level. For Slack, you can use your Git repo’s integrations – e.g., GitHub’s Slack app can notify a channel of new commits or PRs. For Airtable, you could write a script that syncs Airtable data to a YAML/JSON which the CMS uses (or vice versa). Since all content is accessible via Git or the GitHub API, scripting around it is straightforward.

**Cons:**

* **Not Real-Time:** This is not a Google Docs-like editor. Only one person should edit a given document at a time to avoid Git merge conflicts. Collaboration is more asynchronous – multiple people can use the CMS concurrently on different docs, but there’s no awareness of others editing the same piece until after commit. For teams this is usually fine, but it’s not live co-editing.
* **No Built-in Comments:** Decap CMS doesn’t provide commenting on content. However, you can leverage GitHub PR comments for reviews if you use the editorial workflow (PR mode). But that requires some GitHub knowledge. There isn’t an annotation system within the CMS UI itself.
* **Setup and Hosting:** You need to set up the CMS: create a config file, possibly set up an OAuth app on GitHub, and secure the `/admin` path. It’s not extremely hard (Netlify provides a starter template), but it’s more work than a pure cloud service. There’s also no official hosted version – you either host on Netlify (which is free for small projects) or elsewhere.
* **UI is Basic:** While functional, the CMS interface is simpler compared to Notion or GitBook. It’s primarily form-based (for frontmatter fields) and a raw Markdown editor with preview. Non-technical users may need a little training (though it’s much easier than editing in GitHub directly).
* **Limited AI Integration:** Out-of-the-box, no AI features. You would have to create something custom (for example, a script or plugin that calls OpenAI to generate a summary and fills a field). This is doable given the extensibility, but not trivial if you’re not a developer.

**Pricing:**

* **Free:** 100%. There is no paid plan for Decap CMS; it’s completely open. If you use Netlify’s platform, Netlify has pricing for Identity users if you have a large number of them (the first 5 active Identity users are free, beyond that there’s a small fee per user). But many teams stay within free limits. Hosting the site that contains the CMS might incur normal hosting/build costs (Netlify free tier is generous, GitHub Pages is free, etc.). Essentially, **cost is not a barrier with this solution**.

### TinaCMS

**Overview:** TinaCMS is another **Git-backed content management toolkit**. It provides an inline editing experience – you can navigate your site and edit content directly on the page (with a sidebar for fields). Tina has an open-source core and an optional cloud service. It supports Markdown and MDX, and is highly configurable with React. Compared to Netlify CMS, TinaCMS offers a more dynamic, “live preview” editing approach and has built-in support for things like branch-based workflows and even some AI features.

**Pros:**

* **Inline Visual Editing:** TinaCMS can be configured so that your actual site becomes the editor – you click an “Edit” button on the site (when logged in), and you can toggle into edit mode. In this mode, you see a sidebar of fields (frontmatter) and can also click into text areas to edit content, with changes previewed in real-time. This gives non-technical editors immediate context of how their changes look on the page. It feels more **What-You-See-Is-What-You-Get**. There’s also a separate Tina Studio web app if you prefer a central dashboard, but the inline experience is a big draw.
* **MDX Support and Components:** Tina has first-class support for MDX (Markdown with React components). It acknowledges that modern docs often include interactive components. You can define what React components are allowed in MDX and Tina’s sidebar can even provide a UI to edit the props of those components. This means editors can insert something like `<YouTube videoId="X" />` in the content via a friendly form rather than writing raw JSX. **Editing MDX feels natural, not clunky**.
* **Branch/Preview Workflow:** With Tina, you can set it up so that edits are made on a branch, and when ready, merged to main. It has an **“Editorial Workflow” feature that works with Git branches**. For example, an editor could create or edit a draft on a separate branch (with a shareable preview link), and after review, it gets merged to publish. This is great for teams that want a staging environment or approval step, all while using Git under the hood.
* **Tina Cloud API:** Tina offers an optional cloud service which provides a secure GraphQL API layer on top of your content. This can simplify auth and allow content editing without every user needing direct Git access. With Tina Cloud, you also get extras like role management, and recently **AI-assisted editing (Beta)** on higher plans. The AI assist can generate content or metadata in the editor (for example, suggest an SEO description).
* **GitHub Integration:** Like Decap, Tina uses GitHub (or GitLab) as the content store. It can work client-side via the GitHub API or via Tina’s cloud proxy. Every change still ends up as a commit. So you keep full history. Developers can also choose to edit files directly in Git, and those changes will flow back to Tina. It’s all one source of truth.
* **Extensible & Developer-Friendly:** TinaCMS is essentially a React toolkit. You can customize the editing forms, add custom field types (e.g., a color picker field, or even integrate Airtable by making a field pull options from an Airtable base). If you have the resources, you can script a lot. For instance, one could make a custom Tina field that on save sends a message to Slack (though that might be better handled with Git webhooks). The point is, it’s very flexible if you need to tailor the CMS to your needs.
* **Community and Examples:** Tina has a dedicated team (it originated from forestry.io folks) and an active community. They provide examples for Next.js, Docusaurus, Hugo, etc., and have starters (e.g., “Tina + Docusaurus starter”). The documentation is solid. Many early adopters have shared plugins for common needs.

**Cons:**

* **Setup Complexity:** TinaCMS is more involved to set up than Netlify CMS. You typically need to add Tina into your site’s code (as a dependency) and configure schemas for your content collections. It’s a developer’s CMS framework, which means initial overhead. If your team doesn’t have a React developer, this could be challenging.
* **No Out-of-the-Box App (unless using Tina Cloud):** With Decap CMS you drop in an admin and you’re done. With Tina, you either integrate it into the site or use their Tina Cloud, which still needs configuration. It’s not a turnkey SaaS (unless perhaps you pay for a full service plan or hosting).
* **Concurrent Editing and Locking:** Since it operates on Git, it has the same limitation – two people editing the same document at once could cause a merge conflict. Tina Cloud might eventually address this with some locking mechanism, but generally it’s not multi-cursor live editing. It’s more edit–save–publish cycle.
* **Cost for Tina Cloud:** TinaCMS core is free and open-source. However, if you want their cloud features (user management, GraphQL API, etc.), the free tier is limited to 2 users. For larger teams, you’d need a paid plan. The **Team plan** starts around \$25/month (for 3 users) and **Team+** around \$41/month (5 users). Notably, features like the Editorial Workflow and AI assistance are only in the higher “Team Plus” or “Business” plans. If you are fine using Tina entirely client-side with GitHub auth (bypassing Tina Cloud), you can avoid these costs, but you lose some convenience features.
* **No Native Slack or Airtable Modules:** Similar to Decap, there’s no built-in Slack integration. You rely on Git webhooks or custom code for notifications. If an Airtable integration is needed, you’d have to custom develop it (or use Airtable’s API to sync content one-time). Tina’s focus is on being the content source, not consuming other sources – so Airtable as a source of truth isn’t directly supported. You might instead import Airtable data into Markdown and then manage it via Tina.
* **Maturity:** TinaCMS is still evolving. Some features (like live preview) are great, but there might be occasional bugs or needed improvements as it’s a bit newer than Netlify CMS. Always test thoroughly.

**Pricing:**

* **Open Source Version:** Free to use, no limits. You host your content (in GitHub) and you can host the site+CMS anywhere.
* **Tina Cloud:** **Free plan** for 2 collaborators (good to test). Paid **Team** plans start ~~\$24/month (annual) for up to 3 users, and scale up by number of users. The **Team+** (~~\$41/month) and **Business** (\$249/month) add features like AI, workflow, priority support. If your team is small, you might operate on the free plan or avoid Cloud. If large, factor this cost in (though it’s quite reasonable compared to per-seat pricing of fully hosted solutions).

**Use Case Fit:** Git-based CMS solutions are excellent if you want **tight integration with your static site** and full control over content files. Decap (Netlify) CMS is a simpler drop-in with basic features; TinaCMS is a more powerful, future-proof option especially if MDX and a slick UI are important. Choose these if your team is willing to trade off real-time concurrent editing for a **Git workflow with a UI**. They work well for teams where maybe a developer or two set up the system, and less technical writers then use it via a browser. These tools inherently keep relative links stable (since all docs live in the repo). They also make generating frontmatter a solved problem (forms for frontmatter fields). If you need AI to assist with frontmatter or content, TinaCMS (with the appropriate plan) has an edge by offering AI integration in-editor, whereas with Decap CMS you’d DIY a solution. Overall, for **static site publishing pipelines**, these CMS ensure content and code stay in sync and everyone can contribute through a friendly interface.

## CloudCannon (Visual Editor for Static Sites)

**Overview:** CloudCannon is a hosted platform that provides a visual editing layer on top of static site generators. Think of it as a hybrid of a CMS and a static site host: you connect your Git repo (Next.js, Jekyll, Hugo, Docusaurus, etc.), and CloudCannon gives your content team a web interface to edit Markdown, HTML, data files, with live preview. It’s a commercial product (with a free trial) known for its **polished in-context editing** and support of many static site technologies.

**Pros:**

* **Visual WYSIWYG Editing:** CloudCannon lets editors browse the actual website and click content to edit (if it’s Markdown, it opens a rich text editor; if it’s a data field, maybe a form). It has a **Visual Editor** that shows the page and a sidebar for frontmatter, similar to TinaCMS’s approach. Editors see their changes on the page in real-time. This lowers the technical barrier significantly – no need to know Git or Markdown syntax for basic edits.
* **Git-Based and Hosting Combined:** It pulls your site from a Git repo and can even host the generated site. Editors’ changes go back to the repo (CloudCannon can commit changes via Git). You get the benefits of Git versioning under the hood, but the team never has to directly interact with Git. This means content stays as Markdown files, relative links stay intact, and your static site build process remains in place. CloudCannon basically automates the commit and build loop.
* **Support for MDX & Components:** CloudCannon is pretty static-site agnostic. For frameworks like Next.js or Docusaurus which use MDX, CloudCannon allows editing those files. It has a concept of **“Snippets”** for custom components – you can configure how a React component in MDX should be editable (like a form for its props). For example, a `<Youtube videoId="...">` MDX component could be exposed to the editor as a form to paste a YouTube URL. This is powerful for using custom React components in documentation.
* **Frontmatter Management:** The interface can present frontmatter fields in a user-friendly way (text boxes, date pickers, dropdowns for predefined values, etc.). It ensures frontmatter stays in sync. You can even use CloudCannon’s **collections** and **data editor** to manage global data (like an Airtable, but in YAML/JSON files). This can serve as a sort of lightweight database.
* **Collaboration & Drafts:** While CloudCannon doesn’t do real-time multi-user editing, it does allow multiple editors. It has a draft/publish workflow where changes can be reviewed before going live. And because it’s a hosted platform, they could add features like editor user roles, commenting, etc. (It already supports user roles and has an *Audit Trail* for changes on higher plans.)
* **Integrations:** There’s a Slack integration specifically for form submissions (CloudCannon can serve forms on static sites and send results to Slack). For content edits, you would rely on Git notifications. Additionally, CloudCannon’s back-end is extendable via webhooks – e.g., you can trigger a webhook to Airtable or elsewhere when content updates.
* **No Setup for Team:** Because it’s hosted, your team just logs into CloudCannon’s dashboard to edit – no installing software or dealing with GitHub permissions. It’s easier for non-technical folks to adopt. CloudCannon can also handle the site build and hosting (similar to Netlify), simplifying the tech stack to one provider.
* **Professional Support:** Being a paid product, they offer support, which can be handy if you run into issues integrating a particular framework.

**Cons:**

* **Pricing:** CloudCannon is a paid service with no indefinite free tier (aside from a trial or the special Partner program). For a small team, the **Standard plan is \$55/month** (paid annually) which includes 3 users. More users or features bump you to higher tiers (Team plan \~\$350/mo for 15 users). This can be pricey for a smaller project, especially compared to open-source solutions. There is no per-user pricing; it’s tiered by plan, which could be cost-inefficient if you only have, say, 4 or 5 users (you’d be paying for 15 on Team plan).
* **Cloud Dependency:** Using CloudCannon means your workflow depends on their platform. If their service has downtime, your editors might be blocked (though your site itself is static and would remain live). Also, if in the future you wanted to stop using it, you’d have to revert to manual editing or another CMS – the content is all still Markdown so it’s portable, but you lose the editing UI. There’s some vendor lock-in in terms of editing convenience.
* **Less Flexible than DIY Git:** While CloudCannon tries to support many static site tools, if you have a very unique setup, you might hit limits. For example, extremely custom build processes might be hard to configure in their system. Also, certain advanced Git workflows (like complex branching models) aren’t front-and-center (it’s mostly meant for editing one main branch).
* **No Native AI Features (Yet):** There’s no mention of AI-assisted content generation in CloudCannon as of 2025. You could manually use external AI (e.g., copy-paste into ChatGPT) but the platform itself doesn’t provide that help.
* **Basic Collaboration Features:** CloudCannon currently doesn’t have inline commenting on pages. If an editor wants to flag something for review, they might change a status flag or notify via Slack outside the system. It’s more focused on editing and publishing, less on discussing content in-app.
* **Airtable Integration Indirect:** If you treat Airtable as a source of truth for some data, you’d need to sync that into your Markdown or data files. CloudCannon won’t directly talk to Airtable. You might schedule a script or use their API to periodically update certain files from Airtable. This is a custom solution you’d maintain.

**Pricing:**

* **Standard Plan:** \~\$55/month (annual) for 3 users, unlimited sites on that account, 5 custom domains, and 75GB bandwidth. Good for a small team/site if budget allows.
* **Team Plan:** \~\$300/month (annual) for up to 15 users, more bandwidth, advanced collaboration (audit logs).
* They also have an **Enterprise** for large orgs and a **Partner** program for agencies (which has a “Lite” usage-based option).
* No free tier beyond a trial. However, consider the value: it combines hosting + CMS. If you were paying for a host and a CMS plugin separately, the cost might be comparable. For strictly self-hosting enthusiasts, this cost is a con, but for a business, the time saved and support might justify it.

**Use Case Fit:** CloudCannon is ideal if you want a **turn-key editing solution for static sites** and are willing to pay for convenience. It especially shines for teams with limited technical skills – they can update content without ever seeing Markdown or Git, thanks to the visual editor. The content stays as files in your repo, so you don’t lose portability or the benefits of static generation. This platform bridges the gap between the simplicity of something like Notion and the robustness of a Git-based workflow. If your team has struggled with the complexity of Git or static site maintenance, CloudCannon can significantly reduce friction. On the other hand, if cost is a concern or if you prefer open-source solutions, the previously mentioned Git-based CMS options might be better. CloudCannon is a **premium solution** for those who value a polished experience and support.

## Contentful (Headless CMS with Markdown Support)

**Overview:** Contentful is a popular headless CMS (a cloud content database) that is not Markdown-centric per se, but it can store and deliver Markdown content. It provides a web app for content creators with custom content models, and exposes content via APIs (REST/GraphQL) to be used in any site or app. Many Jamstack teams use Contentful as their content backend for static sites. It supports rich text and Markdown fields, and could be an alternative approach to managing documentation.

**Pros:**

* **Robust API and Infrastructure:** Contentful excels in its API reliability and feature set. There are **Content Delivery APIs** (for published content) and **Content Management APIs** (for editing via scripts). If you need to integrate with Airtable or other systems, you can push/pull data via these APIs easily. No 2000 calls/month limit – the free tier allows quite a bit of activity (with certain rate limits, but generally hundreds of API calls/minute). This is far more robust for integration-heavy workflows.
* **Structured Content and Frontmatter as Fields:** Instead of raw frontmatter, Contentful gives you structured fields for each piece of content (e.g., title, slug, summary, body, etc.). This means no worries about YAML syntax – editors fill out forms. The “body” of a doc can be a Markdown field (or Rich Text). Contentful will store Markdown content as you wrote it. When your static site builds, you fetch content via API and can assemble Markdown files or directly render HTML. This structured approach ensures consistency and makes it easy to manage metadata.
* **Real-Time Collaboration & Comments:** Contentful doesn’t allow two people to edit *exactly* the same entry simultaneously (last save wins), but it has mechanisms to prevent overwrites and it shows when someone is viewing an entry. It also provides an **editorial commenting** feature – team members can leave comments on entries (like asking for review or clarification) which is useful for collaboration (available in higher tiers).
* **Media and Embeds:** Contentful handles asset hosting and embeds gracefully. Images and files are stored in its CDN. For embeds like YouTube or tweets, if you use the Rich Text field, it has an Embed option. If you use Markdown fields, Contentful’s editor supports using embedly links inside Markdown. For example, editors can click “Embed external content”, paste a YouTube URL, and Contentful will insert the proper embed code (which is a snippet in Markdown or a reference in Rich Text). So **YouTube and other custom HTML embeds are supported**, either natively or by allowing raw HTML in Markdown.
* **Slack & Other Integrations:** Contentful offers official integrations (apps) like a **Slack app** that can notify a channel when content changes or when someone requests a review. It also has integration with task management (Jira), translation services, etc., through its marketplace. Webhooks can be set up to POST updates to your own endpoints (which could notify Airtable or trigger a site rebuild). This makes automation in your workflow quite powerful.
* **Scalability & Multi-language:** If your documentation needs grow, Contentful can handle thousands of entries, localization, roles and permissions for large teams, etc. It’s a more enterprise-ready solution than some simpler tools.
* **MDX via Structured Fields:** While Contentful doesn’t run React components, you could store “MDX” by splitting components out. For example, you might have a field for “interactive components” where editors pick a component type and fill its data, which your site’s code then injects. This is more complex, but doable. Alternatively, editors can include HTML/iframes in Markdown if needed (Contentful’s Markdown editor allows basic HTML for things Markdown can’t do).
* **AI Possibilities:** Contentful has no built-in AI, but since content is accessible via API, one could use external AI services. For instance, you might run a script that uses OpenAI to generate summaries for all entries and store them in a “summary” field. This isn’t point-and-click, but it’s something a developer could automate.

**Cons:**

* **Not a Doc Writing Interface:** Contentful’s web app is form-based and content chunk–based. It is not as fluid for long-form writing as something like Notion or HackMD. If you use the Markdown editor, it’s basically a plain text area with preview. There’s no live collaborative cursor or rich formatting toolbar (unless using Rich Text, which is a different format). So, the authoring experience is more rigid – good for consistency, but some writers may miss the spontaneity of a Google Docs style environment.
* **No Native Static Site Preview:** Contentful by itself doesn’t know about your static site. You’ll need to set up a preview server or on-demand builds to let editors preview their changes in the actual site. This can be done (Contentful can send a webhook to trigger a deploy preview), but it’s additional setup. Without it, authors are working a bit “blind” aside from the Markdown preview inside Contentful which might not reflect your site’s styling or React components.
* **Complex Integration for Static Site:** To use Contentful, you must integrate its content fetching in your static site generator. For example, using the Contentful API in Next.js (at build time or runtime) to pull docs. This is a coding task – unlike a Git-based CMS that just yields files, here you’re writing API queries and mapping data to pages. It’s a different paradigm (content-as-a-service). If your site is already set up for it, great. If not, it could be a heavy lift for a small team.
* **Pricing Limits on Free:** Contentful has a community free tier (currently - it allows something like 500 content entries and a couple of users). This may be enough for a documentation site initially. But if you exceed that, the paid tiers start around \$489/month (for the “Team” plan). There isn’t a cheap intermediate plan – it jumps to a quite costly level aimed at businesses. This is a big consideration: Contentful is **free to start, expensive to scale**. For open-source or small projects, that price is often prohibitive.
* **Airtable as Source of Truth Not Direct:** If you wanted to continue using Airtable as your primary store for some content and just use Contentful for publishing – that’s not typical. You’d more likely move the content into Contentful entirely. You could sync Airtable to Contentful via their APIs (some have done it for product data, etc.), but it’s custom work and begs the question of why not just use one source. In short, Contentful would want to be *the* source of truth for the content portion of your docs.
* **Learning Curve:** Non-technical editors will need some training to use Contentful (navigating spaces, content models, etc.). It’s built for content managers so it’s not too bad, but it is more complex than a simple Markdown editor. Also, developers have to learn how to model content and use the APIs effectively.

**Pricing:**

* **Community Free:** \~500 entries, 1 space (environment), 2 users, low asset storage. Good for a small docs site to test.
* **Team:** \~\$489/month (as of latest pricing) – significantly raises content limits, user count, roles, etc. This includes things like 5 environments, 10 users, 50k records. It’s aimed at professional use.
* **Enterprise:** Custom pricing, basically for unlimited or high-scale needs.
* Because of this pricing model, Contentful makes sense if your company is willing to invest in a CMS or if you’re on the free tier and can stay within its limits. There are other headless CMS with more moderate pricing (e.g., **Sanity** has a generous free plan and moderate pay-as-you-go, **DatoCMS** or **Strapi (self-hosted)** could be alternatives), but each has its nuances. We focus on Contentful as it’s a strong representative of “headless CMS” approach.

**Use Case Fit:** Contentful is a good alternative if you’re looking for a **more structured, enterprise-ready CMS** and are okay building a custom integration with your site. For a collaborative docs workflow, it offers stability and fine-grained content modeling. It’s especially useful if your documentation needs to be combined with other content types (product info, marketing pages, etc.) in one system. However, if your primary goal is a Markdown docs collaboration (and you don’t need the complexity of a headless CMS), Contentful might be overkill. The ideal scenario for Contentful would be a documentation site that is part of a larger content ecosystem, where multiple stakeholders manage content, and where a **guaranteed uptime, supported platform** is needed. Its ability to handle **Markdown with embedded media** and trigger **Slack notifications** for changes meets many of the requirements, albeit at a higher complexity and cost.

---

## Comparison Table of Key Features

Below is a summary comparing the alternatives across key criteria:

| **Tool / Platform** | **Collaboration** | **Version Control** | **API & Extensibility** | **Static Site Publishing** | **MDX/Embed Support** | **Comments/Workflow** | **Frontmatter & AI** | **Pricing (Free Tier)** |
| ------------------------ | ----------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| **HedgeDoc (self-host)** | Real-time co-editing (like HackMD) | No git, but internal history; can export to GitHub Gist | Basic REST API; self-extensible via code (open source) | Export Markdown then manual integration needed (no direct SSG sync) | Supports Markdown embeds (iframes if allowed) | No built-in comments (live editing only) | No frontmatter; YAML metadata only for HackMD settings; no AI | Free (must self-host server) |
| **Outline** | Asynchronous multi-user (fast, but not simultaneous) | Internal version history; no direct git integration | Full API; Slack integration; self-host or cloud | No native static export (manual export of MD files) | Yes – stores as Markdown; auto-embeds for videos, etc. | Basic draft publish; improving, but needs manual publish step | No frontmatter (metadata stored internally); no AI features | Free self-host; Cloud 30-day trial then paid per user |
| **GitBook** | Real-time collaboration, multi-cursor; comments threads | Internal version history and “Change request” (PR-like) workflow; can sync with GitHub | REST API; webhooks; Slack, GitHub, etc. integrations | Direct publish on GitBook site (supports custom domain); or sync MD to your repo for SSG | Limited MDX (no custom React, but supports HTML embeds and rich content via UI) | Yes – inline comments, review requests | Metadata managed in app (export requires adding frontmatter manually); **AI assistant** helps with writing and Q\&A | Free for small public projects (up to 3 editors); Paid from \~\$5–15/user/mo for private/advanced |
| **Notion** | Real-time multi-user, comments, tasks, very user-friendly | No git; has page history and rollback | API (JSON blocks); extensive integrations (Zapier, Slack); databases for extensibility | Manual export to Markdown or use API scripts to sync to repo | No MDX, but allows embedded iframes, videos, etc. via Embed blocks; exports HTML for those | Yes – inline comments, assignable to users | No native frontmatter (properties serve that role); Notion AI can generate summaries, etc. | Free plan (unlimited pages, 10 guests); Team plans \~\$8–\$15/user/mo for advanced features |
| **Decap CMS (Netlify)** | Async editing (one editor per document at a time) | Uses Git for everything (each change is a commit); can require PRs for review | No native API (content is just in Git); can extend via custom widgets, use GitHub API; Slack via Git hooks | Excellent – content is in repo, static site builds as normal. Can preview via branch deploys. | Yes – edits Markdown files; can be extended for MDX; can insert raw HTML or custom shortcodes | No internal commenting (use GitHub PR reviews if needed) | Full control of frontmatter fields (via CMS config); no built-in AI (custom extension needed) | Free, open-source (no user limits). Hosting of repo/site may incur standard costs (Netlify free tier often enough). |
| **TinaCMS** | Async editing; offers **inline visual editing** on site | Uses Git (commits to branches) with editorial workflow (branching for review) | GraphQL API through Tina Cloud; highly extensible (React plugins); Slack via webhooks | Excellent – content in repo; Tina can provide live preview on site while editing | **Yes – MDX support** out-of-box; can visually edit React components props; embeds through components or HTML | No inline comments yet; branch workflow covers approvals | Frontmatter fields managed via schema; **AI assistance available** (on paid plan) | Core OSS is free. Tina Cloud free for 2 users; paid from \~\$25/mo for more users (with AI, workflow features on higher tiers) |
| **CloudCannon** | Async editing; **visual in-context editor** for non-tech users | Uses Git under the hood (commits changes to your repo); history via Git | Some API/webhook capabilities; built-in Slack form notifications; less need for API since it’s visual | Excellent – directly integrates with static site generator builds; hosts or syncs to repo with site builds | Yes – supports MDX components editing via Snippets; HTML embeds allowed; built-in support for common services | Basic workflow (drafts, approvals); no inline comment threads in UI (rely on external comms) | Frontmatter fields editable via UI; no native AI yet | No free tier beyond trial. Standard \~\$55/mo (3 users), higher plans for more users. |
| **Contentful** | Async editing (content locking to avoid conflicts); comment threads on entries (in higher tier) | Revision history on entries; no Git (content in DB) | **Robust API** (REST/GraphQL); many integrations (Slack, etc.); highly scriptable | Good – static site fetches content via API at build time; need to implement integration code | Partial – Markdown fields support **Embedly** for videos/tweets and allow HTML tags; no React/MDX (would treat as static HTML) | Yes – Contentful web app supports comments and tasks on content items (for team workflow) | Structured fields instead of frontmatter; can auto-generate some (e.g., publish dates). No built-in AI, but can integrate externally. | Free tier (community) 500 entries, 2 users. Team plan \~\$489/mo (big jump) for more content/users. |

*(Sources: HedgeDoc, Outline, GitBook, Notion, Netlify CMS, TinaCMS, CloudCannon, Contentful etc.)*

## Conclusion

When choosing a HackMD alternative, consider your team’s priorities:

* If **real-time collaboration** and open-source are paramount, a self-hosted HedgeDoc gives you HackMD’s functionality without limits, albeit with fewer integration frills.
* If a **Notion-like wiki experience** is desired while still retaining Markdown, Outline or even Notion itself can be leveraged – sacrificing direct static site integration for ease of use, then using export or APIs to bridge the gap.
* For a documentation-centric team that wants **rich review workflows and a hosted platform**, GitBook offers an all-in-one solution with modern features (and even AI help).
* If you want your content version-controlled in Git and readily publishable to static sites, **Git-based CMSs** like Decap CMS or TinaCMS are excellent. Decap is simpler/free, Tina is more advanced (with MDX, visual editing, and optional AI) – both keep your content as Markdown files next to your code, which is optimal for Docusaurus/Next.js pipelines.
* For a **premium visual editing experience** aimed at non-technical editors, CloudCannon can eliminate much of the friction of static site editing – at a higher price point.
* Finally, for a **structured, enterprise approach**, a headless CMS like Contentful decouples editing from deployment entirely, giving you robust APIs, at the cost of some complexity and expense.

Each tool has trade-offs between collaboration features, ease of integration, and cost. Consider the size of your team, the frequency of documentation changes, and how automated you want the publish process to be. Often, a combination of tools might even work (e.g., drafting in Notion, then moving to Git for publication, or using Contentful for some parts of content and Git for others). The good news is that all these alternatives support **Markdown/MDX content and collaborative workflows** to varying degrees, so it’s about finding the right balance for your workflow. With the above options, you can replace or augment HackMD in a way that best fits your static site publishing needs, without breaking your relative links or your budget.