Payload CMS vs Hygraph 2026: Which Headless CMS Fits Your Stack?

Payload CMS fits teams that want self-hosted, TypeScript-native control. These teams are comfortable owning infrastructure, especially inside a Next.js codebase. Hygraph fits teams that want a managed GraphQL API, zero DevOps overhead, and a polished editor experience. The right choice depends on your team's DevOps tolerance, budget, and whether you need code-level customization or content federation.

Key takeaways

• Payload CMS is self-hosted and MIT-licensed with a free core. You pay only for infrastructure, or from $30/month per project on Payload Cloud if you skip self-hosting.
• Hygraph is a managed, GraphQL-only SaaS with a free tier and paid plans starting around $399/month for the Professional tier.
• Payload's Local API and Next.js colocation remove network latency for content queries when the CMS and frontend share a codebase.
• Hygraph's Remote Sources feature can pull external APIs, such as a Shopify catalog, straight into your content graph. Payload does not offer this natively.
• Pick Payload for deep customization and data ownership. Pick Hygraph for a lighter operational load and a polished non-technical editor experience.

Updated 15 August 2026: sources added, experience claims checked against our project record, summary added.

Architecture and Philosophy

These two CMSs come from very different worldviews. That matters more than any feature comparison table.

Payload CMS: Code-First, Self-Hosted

Payload is a TypeScript-first, open-source headless CMS that runs on your own infrastructure. Since the Payload 3.0 release in late 2024, it's built directly on top of Next.js. That's not a typo. Payload literally is a Next.js app. Your CMS admin panel, your API routes, and your frontend can all live in the same project.

The config is code. You define collections, fields, hooks, and access control in TypeScript files. There's no UI for schema building. You write it, commit it, version it. This is either wonderful or terrible depending on your team.

Payload supports both MongoDB and PostgreSQL (via Drizzle ORM) as database adapters. As of 2026, the Postgres adapter has matured and is commonly recommended for new projects.

Hygraph: GraphQL-Native SaaS

Hygraph takes the opposite approach. It's a fully managed platform with a visual schema builder, a hosted GraphQL API, and zero infrastructure to manage. You model your content in their UI, configure webhooks, set up environments, and you're off.

Under the hood, Hygraph runs on a globally distributed edge infrastructure. Their content API is GraphQL-only (no REST endpoint). This is an intentional design choice. They've leaned hard into the GraphQL ecosystem, including support for content federation, remote sources, and union types.

Hygraph is not open-source. You're renting the platform.

Developer Experience

Local Development

With Payload, local dev is just pnpm dev. You get hot reload on your config changes, the admin UI runs on localhost, and you can debug everything in one process. Since it's Next.js, your entire stack, frontend, CMS, and API, runs in a single next dev command. This is genuinely nice. There's no network latency to a remote API during development, no mocking layers, and no separate CMS instances to manage.

Hygraph requires you to work against their cloud API during development. They offer development environments and branching on higher-tier plans, but you're always making network requests. For teams in regions far from their edge nodes, this can add noticeable latency during dev. On the plus side, there's zero setup. Sign up, create a project, start querying.

TypeScript Support

Payload generates types automatically from your config. Since your schema is TypeScript, the types are always in sync. This sounds minor until you've dealt with a CMS where the types drift from reality.

Hygraph requires you to generate types from their GraphQL schema, typically via GraphQL Code Generator. It works, but it's an extra step in your pipeline. If someone changes the schema in the Hygraph UI without updating the generated types, you'll find out at runtime.

Admin UI

Payload's admin panel is React-based and fully customizable. You can swap out field components, add custom views, and inject your own routes. It looks clean and modern as of Payload 3.x, though it won't win design awards. It's functional.

Hygraph's admin UI is polished and built for content editors. The content editing experience is arguably smoother for non-technical users. The sidebar navigation, asset management, and content stage workflows feel more mature from a pure UX view.

Feature	Payload CMS	Hygraph
Local dev	Full local stack	Cloud API only
TypeScript	Native, auto-generated	Via GraphQL codegen
Admin customization	Full React component override	Limited (custom sidebar apps)
Content editor UX	Good, developer-oriented	Polished, editor-focused
Setup time	5-15 min (needs Node + DB)	2 min (sign up and go)

Content Modeling

Payload's Approach

Content modeling in Payload happens in code. Here's a simplified example:

import { CollectionConfig } from 'payload'

export const Articles: CollectionConfig = {
  slug: 'articles',
  admin: {
    useAsTitle: 'title',
  },
  fields: [
    {
      name: 'title',
      type: 'text',
      required: true,
    },
    {
      name: 'content',
      type: 'richText',
    },
    {
      name: 'author',
      type: 'relationship',
      relationTo: 'users',
    },
    {
      name: 'publishedAt',
      type: 'date',
    },
  ],
}

This gets version-controlled, reviewed in PRs, and deployed alongside your application code. Need to add a field? Change the config, run a migration if you're on Postgres, then deploy. The mental model is close to how you'd define a database schema with an ORM.

Payload supports blocks, arrays, groups, tabs, conditional logic, and custom field types. The blocks field type is especially useful for building flexible page builders.

Hygraph's Approach

Hygraph gives you a visual schema editor. You drag and drop field types, configure validations, and set up references between models. It's fast and intuitive for initial setup. Non-developers can understand the schema, though whether they should be changing it is a different question.

Hygraph also supports components (reusable field groups) and union types for polymorphic references. It has a feature called "Remote Sources" that lets you pull external APIs directly into your content graph. That feature is genuinely useful for certain architectures.

The downside? Schema changes in Hygraph happen in their UI. They offer environment branching and schema migrations on enterprise plans, but you don't get the same code-review workflow that Payload provides natively.

API Design and Querying

Payload: REST + GraphQL

Payload gives you both a REST API and a GraphQL API out of the box. The REST API is auto-generated from your collections and follows predictable rules. The GraphQL API is also auto-generated.

Payload also exposes a Local API that lets you query your database directly from server-side code without any HTTP overhead:

// Server component or API route
const articles = await payload.find({
  collection: 'articles',
  where: {
    publishedAt: { less_than: new Date().toISOString() },
  },
  depth: 2,
  limit: 10,
})

This Local API skips the network layer entirely, which makes it fast. When you build with Next.js and Payload in the same project, this is the main way you'll fetch content. It's a real advantage over a remote API.

Hygraph: GraphQL-Only

Hygraph is GraphQL all the way down. No REST API. Your queries look like this:

query GetArticles {
  articles(where: { publishedAt_lt: "2026-01-01" }, first: 10) {
    title
    content {
      html
    }
    author {
      name
    }
  }
}

The GraphQL API is well-designed with solid filtering, pagination, and ordering. They support content stages (DRAFT, PUBLISHED), localization at the field level, and a high-performance read endpoint that serves cached content from the edge.

If your team already works heavily with GraphQL, say with Apollo Client or urql, Hygraph feels natural. If your team doesn't know GraphQL, the learning curve is real.

Performance and Scalability

Payload's performance depends entirely on your infrastructure. On a well-configured VPS with PostgreSQL and proper indexing, the Local API usually returns queries with minimal added latency because it skips the network hop. The REST and GraphQL endpoints, though, carry the usual HTTP overhead on top. Scaling for traffic spikes is your job: add containers, scale the database, or add caching.

Hygraph handles scaling for you. Its edge-cached read API, what Hygraph calls the Content API, serves responses from globally distributed CDN nodes. Hygraph's own documentation points to that edge network as the reason for consistently low read latency worldwide. Matching that without your own infrastructure work is hard on a self-hosted setup.

In production Next.js and Payload builds, adding ISR or on-demand revalidation closes much of that gap for read-heavy pages, since cached pages don't hit the CMS at all after the first request.

Pricing Breakdown for 2026

This is where things get interesting. Here's a breakdown of typical costs for each platform in 2026.

Plan	Payload CMS	Hygraph
Free/Open Source	$0 (self-host, all features)	Free tier: 2 seats, 1M API calls/mo, 500 content entries
Small Team	~$20-50/mo hosting costs	Starter: $0 (limited), Growth: custom pricing
Mid-Scale	~$100-300/mo (VPS + DB + storage)	Professional: starts ~$399/mo
Enterprise	$500-2000/mo infra (varies wildly)	Enterprise: custom pricing
Payload Cloud	From $30/mo per project	N/A

Payload CMS itself is MIT-licensed and completely free. You pay for infrastructure. A VPS at roughly $20/month, a managed Postgres instance at $15-30/month, and S3-compatible storage at $5-10/month gets you a production-ready setup for under $60/month. Payload also offers Payload Cloud, its managed hosting service, starting at $30/month per project, which simplifies deployment.

Hygraph's free tier works for small projects and prototypes. But once your team grows past the free-tier limits, or you need custom roles, multiple environments, or higher API limits, you move to a paid plan. The Professional tier runs roughly $399/month, a real recurring cost for a small team. Enterprise pricing is negotiated case by case and scales with usage, seats, and support needs.

Here's the nuance: if you factor in developer time for managing infrastructure, Hygraph's pricing might actually be cheaper for small teams without DevOps skills. For agencies managing many projects, Payload's free core means your per-project marginal cost is just hosting.

Self-Hosting vs SaaS: The Real Tradeoffs

This is the core tension, and both sides deserve a direct look.

Why Self-Hosting (Payload) Wins

• Data ownership. Your data lives in your database. No vendor can change their terms, sunset a feature, or hold your content hostage.
• No API rate limits. You're limited by your infrastructure, not an arbitrary plan tier.
• Cost at scale. Once you pass a certain traffic level, self-hosted is much cheaper.
• Customization depth. Hooks, custom endpoints, custom field types, admin UI overrides: there's nothing you can't change.
• Colocation with your app. Running Payload and Next.js in the same process removes network latency for content queries.

Why SaaS (Hygraph) Wins

• Zero ops burden. No servers to patch, no databases to back up, no scaling to worry about.
• Global edge performance out of the box. Hygraph's CDN-backed API is fast everywhere without you configuring anything.
• Content federation. Hygraph's Remote Sources feature lets you pull data from external APIs into your content graph. This is genuinely useful for composable architectures.
• Non-developer friendly. Onboarding content editors is simpler when the schema builder is visual.
• Uptime guarantees. Hygraph offers SLAs on its enterprise plans. Self-hosted uptime is your problem.

For teams where infrastructure management is a strength, or where they partner with a Next.js development agency that handles it, Payload is the stronger choice. For teams that want to focus purely on content and frontend development, Hygraph removes real friction.

Authentication and Access Control

Payload

Payload has built-in authentication. Users, sessions, email verification, password reset: it's all there. You can define field-level and collection-level access control with functions:

access: {
  read: ({ req: { user } }) => {
    if (user?.role === 'admin') return true
    return {
      publishedAt: { less_than: new Date().toISOString() },
    }
  },
  update: ({ req: { user } }) => user?.role === 'admin',
}

This is real, code-level access control. You can write any logic you want. Need to check against an external service? Go ahead. Need to restrict access based on the current document's fields? Done.

Hygraph

Hygraph uses a system of permanent auth tokens with configurable permissions. You create tokens with specific content stage access (for example, read PUBLISHED only, read DRAFT, write). For finer-grained control, they support custom permissions tied to roles.

It works, but it's less flexible than Payload's approach. You configure permissions through their UI rather than writing them in code. Complex cases, like "editors can only update articles in their assigned category," need creative workarounds in Hygraph but are simple in Payload.

Plugin Ecosystem and Extensibility

Payload's plugin ecosystem has grown a lot since 3.0. Notable plugins include:

• @payloadcms/plugin-seo for SEO metadata fields and previews
• @payloadcms/plugin-form-builder for dynamic form creation
• @payloadcms/plugin-search for full-text search integration
• @payloadcms/plugin-redirects for redirect management
• Community plugins for Stripe integration, AI content generation, and more

Writing custom plugins is simple since they're just functions that modify the Payload config.

Hygraph's extensibility comes through:

• Apps and sidebar extensions for custom UI elements in the editor
• Webhooks to trigger external workflows on content changes
• Remote Sources to federate external GraphQL and REST APIs
• Management API to programmatically manage schema and content

Hygraph's app marketplace has grown but is still smaller than Payload's plugin ecosystem. The Remote Sources feature, though, has no equivalent in Payload. Being able to stitch a Shopify product catalog directly into your content graph without middleware is genuinely useful.

When to Pick Which

Here is a decision framework based on the tradeoffs above.

Choose Payload CMS if:

• You're a development team (or working with one) comfortable with TypeScript and infrastructure
• You need deep customization of CMS behavior
• Data ownership and vendor independence matter to you
• You're building a Next.js app and want the Local API performance advantage
• You're an agency managing many projects and want to cut per-project licensing costs
• You need complex, code-driven access control

Choose Hygraph if:

• You want zero infrastructure management
• Your team already works in GraphQL
• You need content federation from multiple sources
• Your content editors need a polished, visual editing experience out of the box
• You need strong global edge performance without configuring CDNs
• Your project timeline is tight and you can't afford setup time

Payload was the CMS behind SleepDr.com's rebuild: a WordPress-to-Next.js 15 + Payload CMS + Supabase migration with a HIPAA-safe architecture that took the site's Lighthouse score from 35 to 94 (case study). That project's colocation story and TypeScript-native config are why Payload sits high on our shortlist for Next.js and Astro builds. Teams already committed to a managed GraphQL workflow may still find Hygraph fits better, especially where content federation matters.

There's no shame in either choice. The shame is in picking one without understanding the tradeoffs. If you're not sure which direction is right for your project, we're happy to talk through it.

FAQ

Is Payload CMS really free?

Yes. Payload CMS's core is MIT-licensed and completely free, with no feature paywall or premium tier. Every collection, field type, and access-control feature ships with the open-source package. You only pay for the infrastructure you choose to host it on. Payload also offers Payload Cloud, its managed hosting service, starting at $30/month per project if you'd rather not run your own servers.

Can Hygraph work without GraphQL knowledge?

Content editors can use Hygraph without any GraphQL knowledge, since the visual interface handles all content creation and editing. Developers who query that content for a frontend, though, must write GraphQL, because Hygraph offers no REST alternative. Plan for a learning curve if your team is new to it.

How does Payload CMS handle media and file uploads?

Payload includes a built-in upload system that supports local file storage, S3-compatible storage such as AWS S3, Cloudflare R2, or MinIO, and other adapters. It handles automatic image resizing and focal point selection, generating responsive sizes from your config, so most projects need no extra image-processing library. For most projects, connecting it to an S3 bucket or Cloudflare R2 is the recommended approach.

Does Hygraph support localization?

Yes, Hygraph supports field-level localization. You can mark individual fields as localizable instead of duplicating entire entries for each language. You configure the available locales once in project settings, then editors switch between languages inside the editor. Payload supports a similar field-level model.

Can I migrate from Hygraph to Payload (or vice versa)?

Migrating between Hygraph and Payload is possible in either direction using each platform's export and import APIs. It's not trivial, though, because their content models, especially rich text formats, differ enough that you should plan for a custom migration script and thorough testing. For large content libraries, budget at least 2-4 weeks for a clean migration.

Which CMS is better for e-commerce?

Neither Payload nor Hygraph is an e-commerce platform, but both work well with headless commerce backends. Hygraph has an edge with its Remote Sources feature, which can pull product data from Shopify or commercetools directly into your content graph. Payload requires you to build that integration yourself with hooks and endpoints. For serious e-commerce projects, pair either CMS with a dedicated commerce backend.

How does Payload 3.x compare to Payload 2.x?

Payload 3.x was a major rewrite that turned the CMS into a Next.js plugin instead of a standalone Express app. The CMS and frontend now share one process, which enables the zero-latency Local API, native PostgreSQL support through Drizzle ORM, live preview, and a redesigned admin UI. If you used Payload 2.x and found it limiting, 3.x is worth another look.

What's the best hosting setup for Payload CMS in 2026?

For most projects, a solid Payload setup in 2026 combines a VPS or container platform such as Railway, Render, or Fly.io, managed PostgreSQL from a provider like Neon or Supabase, and Cloudflare R2 for media storage. Together these typically cost $40 to $80 per month for small-to-medium sites. For larger deployments, Vercel with Payload Cloud or a Kubernetes setup works well. Check our pricing page for how we handle infrastructure setup for client projects.