TinaCMS vs Payload CMS

All schemas are TypeScript config files, no GUI limits. Union types, custom components, and hooks all first-class.

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.

Fields and blocks are shared as named exports. Lexical blocks map cleanly to design system components.

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.

Custom TypeScript validators are first-class, the most powerful validation system in any headless CMS.

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.

Admin UI is developer-oriented. Significant customization needed before non-technical editors can work independently.

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.

Live preview via a configurable preview URL. Requires developer setup to connect your frontend deployment.

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.

Drafts, versions, and autosave. Scheduling supported. Approval chains and custom stages need custom code.

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.

Media collections handle uploads with basic resizing on ingest. CDN and advanced transforms need Cloudinary or S3.

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.

No simultaneous editing. Concurrent edit locking prevents conflicts, one editor holds a document at a time.

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.

Access control is extremely powerful, any async function can gate any operation. Field-level access is first-class.

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.

Built-in localization supports field-level variants across all collection and global types, set in schema.

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.

Fallback configured in Payload config and honored by Local API, REST, and GraphQL, a clean open-source implementation.

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.

Docs are well-written and rapidly improving. Schema-generated TypeScript types. REST and GraphQL auto-generated.

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.

Runs inside your Next.js app, the deepest CMS integration possible. Astro and other framework adapters coming.

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.

The Local API gives in-process data access with no HTTP overhead. REST and GraphQL cover external management.

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.

No built-in environment branching, staging requires a separate instance. Payload Cloud adds environments on paid plans.

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.

Self-hosted with no CDN. Asset delivery via S3, Cloudinary, or local disk, CDN is your responsibility to set up.

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.

Requires Node.js and a database. v3 cohabitation removes one service but the database is still your responsibility.

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.

Official Stripe, Cloudinary, and SEO plugins available. Community ecosystem is growing but less mature than others.

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.

Highly active GitHub with fast maintainer response. Discord is engaged and growing since the v3 release.

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.