TinaCMS

tina.io ↗

Founded 2019

Lokman Musliu - Founder and CTO at Lucky Media

Last reviewed: April, 2026

TinaCMS Verdict

3.8/5

Summary

TinaCMS earns its place in the Git-based CMS category by doing something none of its direct competitors can match: letting editors click on text directly on their live page and edit it in a sidebar that updates the preview in real time. That visual editing capability is a genuine differentiator, and for teams where editor experience matters as much as developer control, it tips the decision clearly in TinaCMS's favour over Keystatic or Decap CMS. The trade-off is real complexity: getting visual editing wired up requires developer work, Tina Cloud adds a SaaS dependency that the other Git-based tools do not have, and self-hosting the backend is a meaningful infrastructure undertaking. For projects where visual editing is not required, Keystatic or Decap CMS deliver a simpler setup.

Best For

Teams building on Next.js or React-based frameworks who need non-technical editors to have a visual, click-to-edit experience without abandoning Git-based content storage.

Watch Out

Visual editing requires frontend instrumentation with the useTina hook and React components; Astro support is experimental, and self-hosting the backend involves deploying a database and auth layer.

What Is TinaCMS?

TinaCMS is a Git-based headless CMS with a defining feature that separates it from every other tool in its category: visual in-context editing. Instead of working in a separate admin panel disconnected from the live site, editors can open TinaCMS, navigate to any page, and click directly on text or content blocks to edit them in a sidebar while watching the page update in real time. The content is stored as Markdown, MDX, or JSON in your Git repository, so version control, pull request reviews, and deployment pipelines remain exactly as they are. The CMS does not introduce a separate database.

TinaCMS is the successor to Forestry.io, the Git-based CMS that became widely adopted across the Jamstack ecosystem from around 2017. When the Forestry team decided to build a next-generation replacement rather than iterate on Forestry's architecture, they built TinaCMS and eventually shut Forestry down in April 2023. TinaCMS is the recommended migration path: the team published a migration CLI that converts Forestry configs into TinaCMS's TypeScript-based schema format. The successor is substantially more capable, adding visual editing, a typed GraphQL API, and a developer experience that reflects how frontend development has evolved since Forestry was originally designed.

The editing experience runs through either Tina Cloud, the managed backend service, or a self-hosted backend that you deploy and maintain. Tina Cloud handles authentication, the content GraphQL API, Git integration, and the Editorial Workflow feature that enables draft states and review queues. The schema is defined in a tina/config.ts file at the root of your project, which means content models are versioned, reviewable, and consistent across environments, the same benefits that attract developers to any Git-based CMS.

Key Features

Visual in-context editing: Editors click directly on live page elements to edit them in a sidebar, with real-time preview updates powered by the useTina React hook
Git-based storage: Content lives as Markdown, MDX, or JSON in your repository, no separate database or external content API required
TypeScript-first schema: tina/config.ts defines collections and fields with full type safety; TinaCMS generates a typed GraphQL client from your schema at build time
Generated GraphQL API: A typed client is generated automatically from your schema, enabling type-safe content queries in both static and server-side rendering patterns
Tina Cloud backend: Managed service handling authentication, Git integration, media, and Editorial Workflow, with a free tier for up to 2 users
Editorial Workflow: Draft states, review queues, and branch-based staging available from the Team Plus plan ($49/month), a step ahead of Keystatic and Decap CMS in this category
Self-hosted backend option: Deploy your own backend using Redis or MongoDB with a custom auth provider, removing the Tina Cloud SaaS dependency

Pricing

TinaCMS as a software library is open source. The cost model centres on Tina Cloud, the managed backend that most teams use in production.

Free ($0): Up to 2 users, core visual editing, Tina Cloud-managed Git integration, basic media handling. Covers solo projects and small sites with one or two editors.

Team ($29/month): Removes the user seat cap, scales to larger editorial teams without paying per-seat. Core editing and visual preview included.

Team Plus ($49/month): Adds the Editorial Workflow feature: draft states, in-review status, and branch-based preview environments. This is the minimum viable tier for any client team that needs a formal publish workflow. Worth noting that in 2024 the team moved Editorial Workflow down to this tier from what was previously a Business-only feature.

Business ($299/month): 20 included users, three configurable user roles for more granular permissions, and additional team management tooling. Targeted at agencies managing multiple sites or teams with author/editor/admin role separation.

Enterprise (custom): SSO, SLA, dedicated support, and custom workflow configuration.

Self-hosted backend: Running your own TinaCMS backend means zero Tina Cloud cost but requires you to deploy and maintain a database (Redis via Vercel KV or MongoDB), an auth provider, and a GraphQL API function. It is well-documented for Next.js but adds meaningful infrastructure responsibility.

Our Experience

TinaCMS occupies a specific and defensible position in the Git-based CMS landscape. When a client needs the version-control benefits and zero-database simplicity of a Git-based workflow but their editors are not technical, TinaCMS is the only tool in this category that makes a genuine case for itself. The visual editing experience is not a gimmick: watching content update live while you type in the sidebar is noticeably better for editor confidence than submitting a form and checking a preview in a separate tab. For projects where non-technical editors need to manage content on a site built with Next.js, TinaCMS is the strongest argument we have for staying Git-based rather than moving to a full hosted CMS like Sanity or Contentful.

The honest trade-off is setup investment. Getting visual editing working requires instrumenting your frontend with the useTina hook, configuring preview routes, and adding tinaField helpers to components where click-to-focus is needed. This is developer work that Keystatic and Decap CMS do not require, because they do not offer visual editing. The question is whether the editor experience payoff justifies that setup time on a given project. For a site with one developer and one technically comfortable editor, Keystatic at $0 is almost always the better call. For a site where editors genuinely need to see their changes live before publishing, TinaCMS earns the setup cost.

When Lucky Media Recommends TinaCMS

We reach for TinaCMS when:

The client's editors are non-technical and need to see their content changes in context before publishing
The project is built on Next.js or another React-based framework where the useTina integration is first-class
The team wants Git-based content storage and version control but cannot accept the preview-disconnect that Keystatic and Decap CMS require
The project is moving off Forestry.io and wants the most natural migration path from the same team
Editorial Workflow (drafts, review states, branch previews) is a requirement and the team has budget for at least the Team Plus tier

We would suggest alternatives when:

The project is on Astro and visual editing is not a firm requirement: Keystatic has a cleaner integration and better DX for that stack
The content model is simple and editors are comfortable with a standard form-based admin: Keystatic or Decap CMS offer a simpler, lower-cost setup
Multi-locale content management is required: TinaCMS has no native i18n support
The team needs real-time collaboration between simultaneous editors: TinaCMS is single-user per document
Infrastructure simplicity is a priority: Tina Cloud is a SaaS dependency; Keystatic and Decap CMS require no backend service at all
Budget is very tight and the 2-user free tier is insufficient: Keystatic's free tier is more generous for small teams

faq

Is TinaCMS free?

TinaCMS is open source and the free tier on Tina Cloud supports up to 2 users at no cost. For many small sites and solo projects, the free tier covers production use. The Team plan at $29/month adds more users and removes the seat cap. The Team Plus plan at $49/month unlocks the Editorial Workflow feature, which enables draft states, review queues, and branch-based staging. The Business plan at $299/month adds three configurable user roles and additional team management features. Enterprise pricing is available for large-scale deployments. If you self-host the TinaCMS backend rather than using Tina Cloud, the CMS software itself is free, but you are responsible for hosting your own database and authentication layer.

What is Tina Cloud?

Tina Cloud is the managed backend service for TinaCMS. It handles authentication for editors, the GraphQL content API, Git integration, media management, and the Editorial Workflow feature. Without Tina Cloud, you must self-host the TinaCMS backend: deploying your own database adapter (Redis via Vercel KV or MongoDB), an auth provider, and a GraphQL API endpoint. Tina Cloud is the recommended starting point because it removes all infrastructure complexity. Self-hosting is the right choice for teams with data sovereignty requirements, cost constraints at scale, or a preference for zero vendor lock-in.

Is TinaCMS the replacement for Forestry CMS?

Yes. Forestry.io was built by the same team now behind TinaCMS, and when Forestry shut down on April 22, 2023, TinaCMS was the official recommended migration path. The team published a Forestry-to-Tina migration guide and CLI tool that converts existing Forestry configs into a tina/config.ts schema. TinaCMS is not a straight feature-for- feature port of Forestry: it is a ground-up rebuild that adds visual in-context editing, a typed GraphQL API, and a TypeScript-first schema system that Forestry never had. Teams migrating from Forestry gain significantly better editor and developer experience.

How does TinaCMS visual editing work?

TinaCMS visual editing works by splitting the admin interface into two panes: your live frontend renders in an iframe on the right, and a content editing sidebar sits on the left. When an editor clicks on any instrumented element in the live page, the corresponding field highlights in the sidebar, and any edits typed into the sidebar update the live page preview in real time without a page reload. On the developer side, this requires wrapping page-level data fetching in the useTina hook (a React hook) and ensuring the page renders on a preview route. Fields must be instrumented with tinaField helpers to enable click-to-focus behaviour. It requires React, which is why the experience is first-class in Next.js and requires React component islands in Astro.

How does TinaCMS compare to Keystatic and Decap CMS?

All three are Git-based and store content as Markdown or MDX files in your repository. The differences are meaningful in practice. TinaCMS is the only one with visual in-context editing, a hosted backend (Tina Cloud), and a native Editorial Workflow on paid plans. Keystatic has the cleanest Astro and Next.js integration, the most polished content editing UI, and the most generous free tier for small teams. Decap CMS is the most established, integrates with the widest range of Git backends and static site generators, and is completely free with no SaaS dependency. Choose TinaCMS when visual editing is a firm requirement and you are building with Next.js. Choose Keystatic when developer experience and Astro integration are the priority. Choose Decap CMS when you are on Hugo or Jekyll and want a proven, zero-dependency setup.

Our verdict

Content Modeling
How flexible is the content modelling system?Can you define complex, nested, and relational content types without workarounds?	●●●●●4/5 TypeScript-first defineConfig covers string, rich-text, datetime, boolean, image, number, reference, and object field types. Nested objects and arrays are supported. The reference field handles cross-collection relations cleanly. The ceiling is that all content must map to files in Git, so highly relational or graph-like data models require careful design. Within those constraints, the schema system is expressive and type-safe.
How well does the platform support reusable content blocks?Blocks that map directly to design system components.	●●●●●3/5 Object fields can be shared as reusable templates across collections, and the rich-text field supports a custom component system that maps to frontend design system components. There is no formal global block library, but the pattern is achievable through shared TypeScript definitions. Less elegant than Sanity's Portable Text, but workable for component-based content patterns.
Does the platform enforce content validation rules natively?Required fields, character limits, regex, custom validators.	●●●●●3/5 Required fields, type constraints, and custom validation functions are supported in the schema definition. Cross-field validation and async validators are not natively available. The built-in validation covers the majority of real-world content requirements; teams with complex business rules will need to handle edge cases at the framework layer.
Editor Experience
How intuitive is the editing interface for a non-technical editor?Could a new editor publish their first piece of content within one hour, without help?	●●●●●3/5 The Tina admin UI is clean and reasonably intuitive for non-technical editors. Basic content editing, image uploads, and saving are accessible within an hour for most users. The friction is the Git model: editors need a Tina Cloud account, and saves are commits. For teams on Tina Cloud, the auth flow is handled cleanly. The visual editing mode is the exception, it genuinely reduces the learning curve by letting editors work directly on the page, but it requires developer configuration first.
Does the platform offer live or visual preview of content?As it will appear on the frontend, without developer configuration.	●●●●●5/5 Visual in-context editing is TinaCMS's headline feature and its strongest differentiator in the Git-based CMS category. Editors open the admin, navigate to a page, and can click directly on any instrumented text or field to edit it in a sidebar while watching the live page update in real time. No separate preview window, no publish-then-check loop. The experience is comparable to what Sanity offers via its Presentation tool, but built directly into a Git-based workflow. Requires developer setup via the useTina hook.
How well does the platform handle the full editorial workflow?Drafts, scheduling, approval chains, role-based permissions.	●●●●●3/5 Editorial Workflow (drafts, review states, and branch-based staging) is available from the Team Plus plan at $49/month. It supports draft content, review states, and branch previews managed through the Tina Cloud interface. This is a meaningful step ahead of Keystatic and Decap CMS, which have no equivalent native workflow tooling. Scheduling and approval chains are limited compared to full headless platforms like Sanity or Contentful.
How effective is the media and asset management?Upload, organisation, image transforms, search at scale.	●●●●●3/5 Images can be stored in the Git repo, served via a configured media folder, or handed off to external providers. Tina Cloud supports media offloading to keep binaries out of Git history. The media management UI is functional but not a full DAM: no tagging, no search at scale, no native image transformation pipeline. For blogs and mid-size marketing sites it is adequate; for asset-heavy sites a third-party media provider (Cloudinary, Cloudflare Images) is the recommended complement.
Collaboration
Does the platform support real-time collaboration?Simultaneous editing, presence indicators, inline comments.	●●●●●2/5 No native real-time collaboration. Simultaneous editing by two users on the same document risks a Git conflict. There are no presence indicators or inline comments in the editor. The collaboration model is the Git branch model, which is workable for small teams with good conventions but is not suitable for newsrooms or large content operations.
How granular and practical are user roles and permissions?By content type, locale, or specific fields, not just admin/editor.	●●●●●3/5 Tina Cloud supports user roles with permission scoping. The Business plan adds three configurable roles. Role granularity is at the team and content level rather than field level. Adequate for agencies managing multiple client sites or teams with distinct author and editor roles; not sufficient for enterprise compliance requirements with field-level access control.
Localisation
Is multi-locale content management native?Field-level localisation, not page duplication or plugin workarounds.	●●●●●2/5 No native multi-locale UI. Multi-language sites require manual conventions: separate collection paths per locale or a custom field-based locale pattern. There is no locale switcher in the admin, no translation status tracking, and no locale-aware field configuration. Any project with serious i18n requirements should look at Sanity, Hygraph, or Contentful.
Can editors manage locale fallback logic natively?e.g. show English if French translation is missing.	●●●●●1/5 Locale fallback logic must be implemented entirely at the framework layer. The CMS provides no fallback configuration, no missing translation indicators, and no locale-aware content inheritance. This is a hard blocker for projects with multi-locale requirements.
Developer Experience
How well-documented and developer-friendly is the delivery API?REST, GraphQL, typed SDKs, TypeScript support.	●●●●●4/5 TinaCMS generates a typed GraphQL client from your schema at build time, giving you autocompletion and type safety in your IDE without manual type writing. The official documentation is well-structured, with dedicated guides for Next.js, Astro, and Hugo. The GraphQL layer is a genuine step up from the file-reading approach of Keystatic or Decap CMS, enabling dynamic and static content fetching patterns from the same API.
How fast and friction-free is integration with modern frontend frameworks?Next.js, Astro, Nuxt, Remix, official examples or starter kits available.	●●●●●4/5 Next.js is the primary target framework and the integration is first-class: official starter, documented visual editing setup, and the useTina hook built for React. Astro integration exists with an official starter template, but visual editing with Astro requires React components and the client:tina directive, and is currently listed as experimental. Hugo and other static site generators are supported for basic editing without visual editing. The tighter the React coupling, the better the experience.
Does the platform provide a Management API for programmatic content operations?Bulk import, AI pipelines, scripting.	●●●●●3/5 TinaCMS exposes a GraphQL management API via Tina Cloud or the self-hosted backend, enabling programmatic content reads and writes beyond the admin UI. This is a meaningful step above Keystatic and Decap CMS. The API surface is not as mature as Sanity's Mutations API, but it covers the primary use cases for content seeding, migration scripts, and external integrations.
Does the platform support environment branching or staging environments?For safe content and schema testing before promoting to production.	●●●●●3/5 Branch-based environments are supported in Tina Cloud's editorial workflow. You can point the admin at a specific Git branch, enabling a staging branch workflow alongside production. Tina Cloud handles branch management in the UI on paid plans. On the free tier and in self-hosted mode, environment separation requires manual Git branch conventions.
Performance
Does the platform deliver content via a global CDN?And how does this affect real-world API response times for your frontend?	●●●●●3/5 At build time, content is read from Git via the GraphQL layer and compiled into your static output, so there is no runtime CMS API call for statically generated pages. In visual editing and preview mode, the useTina hook fetches from the Tina Cloud or self-hosted GraphQL endpoint at runtime. Content delivery performance for production sites is excellent (Git-based, no runtime CMS dependency); preview mode adds a network dependency that is acceptable for editorial use but not production traffic.
How straightforward is hosting and deployment?Does the platform reduce or add infrastructure complexity?	●●●●●3/5 Tina Cloud is the zero-infrastructure path: connect your repo, add environment variables, and you have a managed backend. The trade-off is a SaaS dependency that Keystatic and Decap CMS do not require. Self-hosting the backend means deploying a database adapter (Redis/ MongoDB), auth provider, and a GraphQL API endpoint. It is well- documented but adds meaningful infrastructure overhead compared to the file-reading simplicity of other Git-based tools.
Ecosystem & Longevity
How mature and practically useful is the integration ecosystem?Not just quantity, are the integrations your clients actually need available and well-maintained?	●●●●●3/5 Official integrations and starters exist for Next.js, Astro, and Hugo. The plugin surface is smaller than Sanity or Contentful but larger than Keystatic. TinaCMS has a media adapter system for external asset providers. The ecosystem is focused rather than broad, covering the most common Jamstack use cases without the breadth of a larger platform.
How active and meaningful is platform development?Community health, release cadence, direction of travel.	●●●●●3/5 TinaCMS has approximately 12,000 GitHub stars as of early 2026, ahead of Keystatic (~2,000) and behind Decap CMS (~18,000). The project is backed by a dedicated company (the former Forestry team), which gives it more active development momentum than the community- maintained Decap CMS post-rebrand. Release cadence is consistent, the GitHub Discussions board is actively monitored, and the team ships meaningful features. The risk profile is lower than community- only projects but higher than a fully enterprise-funded platform.
Final verdict	3.8/5