Hygraph

Hygraph's schema builder is one of its genuine strengths. Content types are modeled as a GraphQL schema with rich field types: Single/Multi-line text, RichText, Markdown, Integer, Float, Boolean, Date, DateTime, Color, Location, JSON, Enumeration, Asset, and Reference. Union type fields allow a single field to accept multiple content types — a capability that Contentful lacks natively. Nested component types (reusable embedded objects) reduce content duplication. Schema changes are managed through the UI or Management API. No code-first schema definition like Sanity, but the UI-based approach is accessible to non-developers for schema management.

Graph-native bidirectional relationships are Hygraph's core differentiator in content modeling. Unlike REST-based CMS platforms where references are unidirectional, Hygraph's GraphQL-native architecture makes every reference queryable from both ends without additional API calls. One-to-one, one-to-many, and many-to-many relationships are all first-class. Reverse field access (e.g., 'all Blog Posts that reference this Author') is automatic. Union type references allow a field to reference multiple content types (polymorphic associations). This is a clear capability advantage over Contentful and Storyblok for complex content graphs.

Hygraph supports nested content modeling through its Component types — reusable embedded objects that can be nested within entries without creating separate top-level documents. This provides Storyblok-style component nesting without the overhead of managing independent entry relationships. The RichText field supports embedded entries and assets inline, similar to Contentful. Block-based content composition is well-supported for structured authoring. The schema-driven approach means content structure is explicit and validated, not freeform blobs.

Standard content validation including required fields, unique constraints, minimum/maximum values (for numeric and text length), regex patterns, and enumeration-constrained options. Custom validation logic can be implemented via mutation webhooks that fire before content is saved. Field-level validation errors surface in the editor UI. Cross-field validation requires webhook-based custom logic. Validation rules are schema-level (applied consistently across all editors) rather than per-editor overrides. Solid but not exceptional.

Hygraph maintains content version history allowing editors to review and restore previous versions. Content stages (e.g., DRAFT, PUBLISHED) provide a publishing lifecycle. Scheduled publishing is available on paid plans. However, there is no Contentful-style snapshots API with deep programmatic access to historical versions. Content branching (working on a parallel version of an entry) is not supported. For large teams requiring fine-grained version control, this is less mature than Contentful or enterprise DXP platforms. The version history is accessible in the editor UI and via API but with less control than needed for complex editorial workflows.

Hygraph has historically been a form-based editor — editors fill out fields in a structured form rather than editing content in a visual page context. In 2025, Hygraph launched 'Click to Edit' (live preview editing) which allows editors to click elements in a frontend preview and have the corresponding field highlighted in the editor. This improves the editorial experience significantly compared to pure form-based editing, but it is not a full in-page WYSIWYG visual editor like Storyblok's visual editor. Component drag-and-drop page building is not natively supported — Hygraph remains a content repository with a linked preview experience rather than a layout management system.

Hygraph's RichText field uses a structured AST (Abstract Syntax Tree) format called the Hygraph Rich Text format. Standard formatting (headings, bold, italic, lists, links), embedded asset blocks, and embedded entry blocks are supported. The output is a portable AST that can be rendered with official renderers (@graphcms/rich-text-react-renderer and others). Custom embedded components can be referenced from rich text. The implementation is solid but the toolbox is somewhat leaner than Sanity's Portable Text, which offers more extensibility. Copy-paste from Google Docs and Word preserves basic formatting. Table support is available.

Built-in media library with image upload, storage, and delivery through Hygraph's CDN. URL-based image transformations (resize, crop, quality, format conversion to WebP) are supported via URL parameters. Focal point selection for smart cropping is available. Basic metadata fields (title, alt text, description) on assets. No auto-tagging or AI-powered asset organization. The media library is functional for typical headless CMS needs but is not a replacement for a dedicated DAM. Cloudinary integration available as an external DAM option for teams needing advanced DAM features.

Hygraph uses optimistic locking for concurrent editing — if two editors save the same entry simultaneously, a version conflict is raised for resolution. No true real-time co-editing (like Google Docs or Sanity's real-time presence). The Content Workflows feature (2025) adds structured collaboration through approval stages with role-based permissions, which improves the collaboration experience for editorial teams even without real-time co-editing. Comments and @mentions within the workflow stages provide async collaboration. For teams needing real-time presence and co-editing, Sanity leads the market here.

Content Workflows was launched as a core feature in 2025, giving Hygraph significantly stronger editorial workflow capabilities. Custom workflow stages beyond the basic DRAFT/PUBLISHED binary are configurable. Role-based permissions control who can transition content between stages. Notification hooks fire on stage transitions for team awareness. Scheduled publishing works within the workflow. Compared to peers: more flexible than Kontent.ai's fixed workflow, comparable to Contentful Premium tier workflows, but less mature than enterprise DXP platforms like Sitecore or Contentstack. The 2025 launch is a meaningful capability addition.

GraphQL-only delivery is Hygraph's core architectural identity. The content delivery API is a schema-introspectable GraphQL endpoint with auto-generated queries based on your content model. Filter, sort, paginate, and nest relationships in a single query — eliminating the over-fetching inherent in REST-based CMS APIs. The Content Federation capability is unique: remote REST or GraphQL APIs (e.g., Shopify, external databases) can be federated into the Hygraph GraphQL endpoint, allowing clients to query external data alongside CMS content in one request. The absence of a native REST delivery API is a genuine limitation for teams with REST-only consumers or developers unfamiliar with GraphQL, which prevents a perfect score. The Management API is REST-based for schema and content operations.

Content delivery is served through a global CDN with automatic cache invalidation on content publish. CDN coverage is adequate for global deployments. Response times for cached content are fast. Cache purge on publish is typically sub-second. Asset delivery has separate CDN coverage with image transformation support. Edge computing and edge-side personalization are not built in — those require Vercel Edge Functions or Cloudflare Workers on the frontend. Overall CDN strategy is solid but not as deeply documented as Contentful's Fastly-backed delivery.

Comprehensive webhook support covering content create, update, publish, unpublish, delete, and schema change events. Webhooks can be filtered by content model and event type. Custom HTTP headers and payloads configurable. Retry logic with exponential backoff on delivery failure. Webhook delivery logs available for debugging. Both content mutation and content stage transition webhooks are supported. The webhook system is well-implemented for a headless CMS — adequate for most integration patterns including cache busting, search index updates, and downstream notifications.

True headless architecture delivering content to any channel via the GraphQL API. Official SDKs primarily for JavaScript/TypeScript with community libraries for Python, Ruby, and other languages. GraphQL's declarative query language makes it particularly efficient for multi-channel scenarios — each channel queries exactly the fields it needs with no over-fetching. Content Federation extends multi-channel delivery to include remote data sources federated into the graph. Web, mobile (iOS/Android), kiosks, and custom applications all consume the same endpoint. The absence of a REST API limits compatibility with some older systems or tools that don't support GraphQL, but for modern multi-channel architectures, Hygraph's headless delivery is strong.

No native audience segmentation engine. The Variants feature (2025) allows editors to create content variations that can be served to different audiences, but there is no built-in rules engine for defining those audiences, no CDP integration, and no behavioral tracking. Audience definitions must come from the consuming application or an external CDP/personalization service. Teams requiring meaningful audience segmentation need Segment, LaunchDarkly, or a dedicated personalization layer on top of Hygraph. The Variants feature is the foundation for personalization but is not a complete segmentation solution.

The Variants feature provides the content layer for personalization — editors can create locale-equivalent content variants tagged for specific audiences. When combined with a frontend personalization library (e.g., Ninetailed, Optimizely, or custom logic), contextual content serving becomes possible. This is more capability than most pure headless CMS platforms offer natively. However, the personalization logic itself (who sees which variant, under what conditions) lives entirely outside Hygraph. The platform provides the content infrastructure for personalization but not the decision engine.

No native A/B testing platform. Content Variants could theoretically serve as A/B content buckets if the consuming application implements traffic splitting and assignment. However, Hygraph provides no test management UI, no traffic allocation controls, no statistical significance calculations, and no results reporting. Experimentation requires fully external tools (LaunchDarkly, Optimizely, VWO) with Hygraph serving as the content store. This is comparable to Contentful's position before the Ninetailed acquisition — a content infrastructure platform without native experimentation.

No native content recommendation engine. No ML-based content recommendations, algorithmic ranking, or collaborative filtering. Related content must be manually curated via reference fields or computed externally. For recommendation functionality, teams rely on Algolia Recommend, AWS Personalize, or custom embedding-based solutions. Fully consistent with headless CMS architecture philosophy but provides no value here.

The GraphQL Content API supports filtering and basic full-text search capabilities via where clauses with _contains and _search operators. Field-specific filtering is well-designed (exact match, contains, startsWith, not, etc.). However, true full-text search with relevance scoring, faceting, typo tolerance, and autocomplete requires an external search service. The search primitives are more query-capable than Contentful's CDA (thanks to GraphQL filter syntax) but still fall short of what production content discovery experiences require without supplementation.

Good integration path for external search services. Webhooks on content publish/unpublish/delete enable real-time index synchronization with Algolia, Typesense, or Elasticsearch. The GraphQL API can be used to batch-export content for index building. No native search pipeline hooks or middleware. The Content Federation capability allows federating a search API into the Hygraph endpoint (interesting but complex to implement for search). Standard webhook-to-indexer patterns work well for common search integration needs.

No native vector or semantic search. Hygraph's 2025 AI features (AI Assist, AI Agents) focus on content generation and classification rather than search intelligence. Semantic search would require external vector databases (Pinecone, Weaviate, pgvector) with custom embedding pipelines built outside Hygraph. Content Federation could theoretically federate a vector search API into the Hygraph graph, but this is a custom integration pattern rather than a supported feature. An emerging area where Hygraph has not yet invested.

No native commerce capabilities. No product catalog management, no cart or checkout, no pricing or inventory management, no order processing. Hygraph is a pure content platform. However, the Content Federation capability is designed precisely for composable commerce scenarios — federating a Shopify or commercetools GraphQL API into the Hygraph endpoint to create a unified content+commerce graph. This is an architectural approach rather than native commerce, but it represents a genuine differentiator in headless commerce scenarios.

Content Federation is Hygraph's standout feature for commerce integration. By federating a Shopify, commercetools, BigCommerce, or custom commerce API into the Hygraph GraphQL endpoint, teams can query product data and CMS content in a single GraphQL request. This eliminates the 'call CMS, then call commerce API' pattern in frontend applications. The integration is available from the Growth plan for remote sources. The implementation requires understanding of GraphQL federation patterns and some configuration work, but the capability is genuine and unique among headless CMS platforms. No lightweight product picker UI like Contentful's marketplace apps.

Product content can be modeled using Hygraph's generic content types — product descriptions, enriched copy, variant content, brand guidelines. The bidirectional relationship system makes product-to-category and product-to-attribute modeling cleaner than in flat CMS architectures. However, there's no purpose-built PIM: no SKU management, no pricing rules, no stock-keeping logic, no variant/option management. Product content management works for editorial enrichment but not as a primary PIM replacement.

Usage analytics covering API call counts, bandwidth consumption, and asset storage are available in the dashboard. No content performance analytics, no author productivity metrics, no content engagement tracking, and no content lifecycle dashboards. Analytics that exist are operational (monitoring plan usage and limits) rather than strategic (understanding content effectiveness). Comparable to Contentful's limited analytics posture.

Being headless, analytics integration is primarily a frontend concern. Webhooks can stream content lifecycle events (publish, delete, update) to analytics pipelines for content operation tracking. Content Federation could federate an analytics API into the Hygraph graph for unified querying (advanced pattern). Standard analytics tools (GA4, Segment, Mixpanel) integrate at the application layer without CMS constraint. The GraphQL API makes it easy to pair content with external analytics data in frontend applications.

The Taxonomies feature (2025) provides structured content classification that enables content intelligence patterns — organizing content by topic, audience, content type, and other axes. AI Agents can perform content analysis and classification tasks. However, there's no content scoring, no gap analysis, no ROI tracking, and no content health dashboards. The intelligence features are foundational (classification taxonomy) rather than strategic (measuring content effectiveness). More mature platforms offer built-in content performance analytics that Hygraph lacks.

Multi-project architecture allows separate projects per site or brand, each with independent content models, content, and environments. Organization-level management provides umbrella visibility and user management across projects. Unlike Contentful's space model, Hygraph's project architecture is designed with multi-tenant use cases in mind. Content Federation enables sharing data across projects via API federation patterns. However, native cross-project content sharing (e.g., global components referenced in multiple sites) is not a built-in feature — it requires Content Federation configuration.

Field-level localization is well-implemented in Hygraph. Each field can be independently localized, with locale fallback chains configurable in project settings. Locale-specific publishing allows publishing content in one locale without affecting others. Multiple locales can be managed within a single entry. The Hobby tier includes 2 locales; Growth and Enterprise tiers allow more. The implementation is clean and comparable to Contentful's localization strength. Content queries can filter by locale and specify fallback behavior. Solid localization foundation for multi-market deployments.

Official integrations with Lokalise and Crowdin for TMS connectivity. Translation export/import workflows are supported via these integrations and via the Management API for custom pipelines. Machine translation can be triggered through integrated tools or external services. The translation integration story is adequate but the marketplace of TMS connectors is smaller than Contentful's. Bulk translation operations are supported programmatically.

Organization-level user management provides central control over members and billing. Projects provide brand-level isolation with independent content models and environments. Role-based access control can be configured per project. Content Federation enables some cross-brand content sharing patterns. However, centralized approval workflows across brands, global component libraries, and enforced brand governance policies are not natively supported — they require process or custom tooling. The multi-project architecture is an improvement over Contentful's space model for multi-brand but still lacks the governance depth of Contentstack or enterprise DXP platforms.

AI Assist (launched 2025) provides in-editor content generation, rewriting, expansion, and summarization for text fields including RichText. The feature is integrated into the content editor UI and supports prompt-based content creation. Multiple AI generation templates are configurable. However, brand voice controls are limited, content-type-aware generation (generating content that respects field context beyond generic text) is basic, and the feature set is less sophisticated than purpose-built AI writing tools. Useful as an editorial productivity aid but not a transformative capability.

AI Agents (2025) provide workflow automation capabilities — AI agents can be configured to perform automated content tasks such as translation, classification, quality checking, and metadata generation. The MCP Server integration allows connecting Hygraph to AI agent frameworks and LLM-powered tools. Taxonomies integration with AI enables automatic content classification. This is a more advanced AI workflow story than most headless CMS competitors. The 2025 AI roadmap has been ambitious, though the maturity of these features is still early.

AI Assist and AI Agents include basic content safety filtering on generated text. No formal brand voice enforcement engine, no AI audit trails for generated content, no hallucination detection or confidence scoring. Data processing terms cover AI features in the DPA. Custom AI model configuration is not supported — teams use Hygraph's default AI integration. For organizations with strict AI governance requirements, the lack of auditability and brand control is a gap. This is consistent with the early stage of AI governance tooling across the CMS industry.

Hygraph's GraphQL-native API design is the platform's signature strength. The schema is auto-generated from the content model, giving developers a self-documenting, introspectable API without manual endpoint configuration. The query language supports nested field selection, filtering, ordering, pagination (cursor-based and offset), and relationship traversal in a single request — eliminating the over-fetching problems of traditional CMS REST APIs. Content Federation extends the GraphQL schema with remote sources, creating a unified API surface for content and external data. The Management API (for schema changes) is REST-based, which is appropriate for its use case. The primary limitation is the absence of a REST content delivery option for teams with REST-only toolchains or developers unfamiliar with GraphQL.

CDN-backed content delivery with global PoP coverage provides consistent read performance for cached queries. GraphQL response times for uncached queries depend on query complexity and relationship depth. Rate limits are plan-dependent: Hobby tier allows 500K API calls/month, Growth 1M+, Enterprise custom. Cursor-based pagination handles large datasets efficiently. Complex deeply-nested GraphQL queries can be slower than comparable REST responses — proper query design is essential. No documented query complexity limits that would cause unexpected rejections, though Hygraph reserves the right to throttle complex queries.

JavaScript/TypeScript is the primary SDK with a community-maintained package (@hygraph/client or using any standard GraphQL client like Apollo, urql, or graphql-request). Rich Text rendering packages available for React and HTML. Unlike Contentful, there are no official SDKs for Python, Ruby, Java, .NET, or mobile platforms — teams use standard GraphQL clients in their preferred language. This is less friction than it sounds for GraphQL (any GraphQL client works) but the lack of official high-level SDKs for non-JS languages means less scaffolding and community resources for non-JavaScript implementations.

Hygraph has a growing integration marketplace with connectors for Lokalise (translation), Crowdin (translation), Cloudinary (DAM), Bynder (DAM), and various deployment tools. The marketplace is significantly smaller than Contentful's 100+ apps but covers the key integration categories. The Content Federation capability partially offsets the smaller marketplace — instead of needing a dedicated marketplace app for commerce, teams federate the commerce API directly. The developer ecosystem for building custom extensions is smaller, but the fundamentals (webhooks, Management API, UI extensions) allow custom integrations.

Hygraph supports UI extensions (custom field editors and sidebar plugins) built with JavaScript/TypeScript. The App SDK provides hooks for field customization, UI injection, and widget rendering. Custom fields can replace standard field editors with custom input components. Webhooks provide server-side extension points for integration automation. The Content Federation feature enables server-side schema extension via remote source integration. There are no server-side hooks for request interception or response transformation within the Hygraph API itself. Extensibility is primarily UI-layer and integration-layer, not middleware-layer.

SSO via SAML 2.0 and OIDC available on Enterprise plans. MFA (two-factor authentication) available for all users. Content API access uses permanent API tokens (Public API Endpoint) with optional content permissions scoping. Management API uses PATs (Personal Access Tokens) or service account tokens. OAuth-based access for UI extension apps. The authentication model is standard and functional. SSO being Enterprise-only is a limitation for mid-market buyers, consistent with most headless CMS competitors.

Custom roles with configurable permissions allowing fine-grained control over content create, read, update, delete, and publish operations per content model. Public Content API can be scoped to specific models and operations using Permanent Auth Tokens. However, field-level permissions are not supported — you can restrict access to a content model but not to individual fields within it. Content-instance access control (e.g., only see entries tagged for 'brand-x') is not natively available. For complex multi-tenant permission scenarios, the authorization model is capable but requires creative configuration.

Hygraph holds SOC 2 Type 2 certification, GDPR compliance with DPA available for all customers, and ISO 27001 for infrastructure. EU data residency is available. No HIPAA BAA offered (healthcare use cases require careful evaluation). No FedRAMP authorization. The compliance posture is solid for a company of Hygraph's size and tier — the SOC 2 Type 2 and GDPR credentials meet the requirements of most enterprise and regulated industry buyers outside healthcare and US federal government. Certificates are referenced on the security page.

No major publicized security breaches in Hygraph's history. The company maintains a responsible disclosure policy ([email protected] for reporting). Hygraph is hosted on AWS with its security practices. No public bug bounty program. As a smaller company than Contentful or Salesforce, security communications are less comprehensive. The SaaS model means infrastructure security is managed by Hygraph's team. Given the limited public information, confidence is LOW.

SaaS-only with no self-hosted option. This simplifies operations significantly but eliminates deployment flexibility for organizations with strict data sovereignty requirements beyond EU/US region choice, private cloud mandates, or air-gapped environments. The multi-tenancy model (shared infrastructure on lower tiers, dedicated on Enterprise) follows industry norms. EU and US regions available for data residency. For organizations comfortable with managed cloud SaaS, this is a non-issue. For regulated industries or large enterprises requiring private deployment, this is disqualifying.

99.95% uptime SLA on Enterprise plans. Standard plans do not include a formal SLA. Public status page (status.hygraph.com) with historical incident records and uptime metrics. The content delivery API benefits from CDN redundancy, providing high effective availability for read operations. Incidents are communicated via the status page. Response and resolution SLAs for Enterprise support are defined in enterprise agreements. Solid SLA positioning comparable to peers.

Hygraph serves enterprise customers at scale with the CDN-backed delivery layer handling high read throughput. Auto-scaling is managed by Hygraph on AWS infrastructure. GraphQL query complexity can become a performance consideration at high scale — teams need to design efficient queries. Content entry limits are generous on paid plans. The platform has demonstrated ability to handle enterprise traffic volumes. No independent horizontal scaling controls for customers.

Automated backups managed by Hygraph on AWS infrastructure. Full content export available via Management API (entries, assets, schema). The exported content is in Hygraph's own format requiring transformation for other platforms. RTO/RPO are not publicly documented with specifics. Multi-AZ deployment on AWS provides infrastructure-level redundancy. Content portability is reasonable — a motivated team can export all content and schema definitions. Not as mature a disaster recovery story as enterprise DXP platforms but adequate for cloud-native SaaS.

No local Hygraph server or emulator — development always requires working against the remote API (dev project or personal project). Hygraph CLI provides project management and content operations. Since Hygraph is GraphQL-native, any GraphQL IDE (GraphiQL, Altair, Insomnia) works as a local development tool against the remote endpoint. Compared to Contentful's identical no-local-emulator limitation, Hygraph's Management API is slightly more accessible for automation. GraphQL introspection means local tooling (type generation, schema validation) works offline against cached schema. The lack of a local emulator is a structural limitation but not unique to Hygraph.

Environments feature allows separate dev/staging/production content environments within a project. Management API enables programmatic schema changes for code-driven deployments. Webhooks trigger downstream CI/CD processes (e.g., Next.js static regeneration, search index updates). Schema can be exported and version-controlled. Migrations are less formalized than Contentful's migration CLI pattern — there is no first-class migration script runner. Environment promotion (moving schema from dev to production) requires either manual UI steps or custom Management API scripting.

Hygraph's documentation is well-organized with clear separation between content modeling, API usage, integrations, and platform administration. The GraphQL playground is embedded in the console for interactive query exploration. Getting started guides exist for Next.js, Nuxt, Astro, SvelteKit, and other frameworks. API reference is auto-generated from the GraphQL schema. SDK and integration documentation covers the main use cases. Some areas (advanced Federation patterns, complex content model scenarios) could use more depth. Documentation quality has improved significantly since the Hygraph rebrand (previously GraphCMS).

First-class TypeScript support is a genuine Hygraph advantage. The GraphQL schema auto-generates TypeScript types via community tools (graphql-codegen is the primary workflow). This provides end-to-end type safety from content model to frontend rendering — a significant DX improvement over REST-based CMS platforms with manual type definitions. Rich Text types and relationship types are included in generated type output. The type generation workflow is standard GraphQL ecosystem tooling (not Hygraph-proprietary), which means broad IDE support and tooling compatibility.

Hygraph ships continuously as a SaaS platform with frequent updates. The 2025 release calendar was particularly active: AI Assist, AI Agents, Content Workflows, Variants, Taxonomies, Click to Edit, and MCP Server integration all shipped as named features. SDK releases follow regular cadence. The company is in a growth phase where product velocity is high. The pace of 2025 releases suggests an aggressive product team pushing the platform forward, which is positive for momentum tracking.

Hygraph maintains a changelog and blog with feature announcements. Major features are announced via detailed blog posts with context, use cases, and documentation links. SDK releases follow conventional changelog format. However, there is no granular 'what changed this week' changelog for the SaaS platform itself — minor improvements and bug fixes are not always documented publicly. The changelog quality is adequate for tracking major capabilities but not detailed enough for organizations that need to audit every platform change.

Hygraph communicates roadmap direction via blog posts, conference talks, and enterprise customer briefings. There is no fully public roadmap with community voting (unlike platforms like Sanity's Slack-based roadmap transparency). Early access programs allow customers to preview upcoming features. The 2025 AI roadmap was communicated through product marketing. Transparency is moderate — better than fully opaque, but organizations that want to plan multi-quarter implementations around upcoming features need Enterprise access to get reliable roadmap visibility.

The GraphQL API versioning is conservative — Hygraph avoids breaking changes to the delivered API surface because the schema is user-defined (content model changes are the customer's responsibility, not Hygraph's). Infrastructure-level breaking changes are rare and handled with deprecation notices. SDK updates follow semver. The Management API version is maintained with backward compatibility. Content model schema changes are the primary source of 'breaking' behavior, but those are customer-initiated. Hygraph's own platform changes rarely break existing integrations.

Hygraph's community is active but significantly smaller than Contentful's or Sanity's. Discord community (~5,000 members) is the primary community channel. GitHub stars on community SDKs and Rich Text renderer packages are in the thousands. Stack Overflow coverage is thin for Hygraph-specific questions. The community grew following the Hygraph rebrand (from GraphCMS) as the GraphQL headless CMS niche expanded. G2 review volume (716 reviews) is surprisingly strong for a platform of this size, suggesting an engaged but still niche user base.

Hygraph team members are responsive in the Discord community with relatively quick answers to questions. GitHub issues on SDK repositories receive prompt attention. The company demonstrates genuine community investment through developer relations activities. Response times in community channels are generally better than Contentful's (possibly due to smaller community volume). Conference presence at JAMstack Conf and GraphQL Summit keeps the technical community engaged. The quality of engagement exceeds what the raw community size might suggest.

Hygraph has a Solutions Partner program with agencies and system integrators specializing in headless CMS implementations. The partner network is smaller than Contentful's certified partner ecosystem but includes quality boutique agencies with GraphQL expertise. Vercel, Netlify, and major cloud providers are listed as technology partners. The partner ecosystem is growing but not yet at the scale where finding a qualified Hygraph partner in any market is straightforward. Enterprise buyers may need to validate regional partner availability.

Tutorial content is available through official documentation, YouTube (Hygraph channel with ~10K subscribers), and community blogs. Framework-specific tutorials for Next.js, Nuxt, Astro, and SvelteKit are available. GraphQL community resources (beyond Hygraph-specific) also serve Hygraph users given the technology overlap. Content volume is growing but smaller than Contentful's mature content library. Some content still references the old 'GraphCMS' brand name, creating minor confusion. Udemy and Pluralsight coverage is minimal.

Finding developers specifically experienced with Hygraph is harder than finding Contentful-experienced developers. However, the required skills (GraphQL, TypeScript, modern JavaScript frameworks) are broadly available in the developer market. A competent TypeScript/GraphQL developer can become productive with Hygraph in days rather than weeks. The Hygraph-specific knowledge surface (content federation configuration, schema modeling, management API) is learnable. The talent pool is supplemented by the transferability of GraphQL skills from adjacent ecosystems.

Strong customer momentum signals for its market tier. 716 G2 reviews with 4.5/5 average is above-average engagement for a platform of Hygraph's size. #1 for Implementation in Headless CMS (G2) 5 consecutive times is a meaningful differentiation signal. #1 for Enterprise Usability 3 times. Enterprise customer logos include recognizable brands. The Content Federation and AI features launched in 2025 have generated positive press coverage. The platform is gaining mindshare in the 'GraphQL-first' headless CMS segment.

Hygraph (formerly GraphCMS) has raised Series B funding (~$30M as of 2022 from One Peak Partners and others). The company is smaller and has raised less than Contentful's $300M+ but operates in a more capital-efficient manner. The company has been growing and is moving toward profitability. No acquisition announcements or distress signals as of 2026. Moderate acquisition risk as a quality asset in the headless CMS space. The Series B positions them as a stable mid-tier SaaS company, not a startup at risk but also not a mature enterprise vendor with deep resources.

Hygraph occupies a clear differentiated position as the GraphQL-native headless CMS with Content Federation. G2 recognition (#1 Implementation, #1 Enterprise Usability) provides third-party validation. The platform is recognized in the headless CMS analyst space (mentioned in Gartner and analyst reports on composable CMS). The differentiation against Contentful, Sanity, and Storyblok is clear: GraphQL-native with federation capability. The competitive moat is moderate — larger platforms are adding GraphQL support, but Hygraph's federation and schema-first approach are harder to replicate. Market penetration is smaller than Tier 1 competitors but growing in the developer-led segment.

Customer sentiment is notably strong for Hygraph's tier. G2 4.5/5 from 716 reviews represents above-average satisfaction for a headless CMS platform. The #1 Implementation award won 5 consecutive times signals that customers consistently find Hygraph faster to implement than alternatives — a key practical advantage. Common praise themes: GraphQL API quality, content modeling flexibility, fast onboarding, excellent customer support responsiveness. Common criticisms: pricing jump from free to Growth ($199/mo), limited REST API option, smaller ecosystem than Contentful. The sentiment is meaningfully more positive than Contentful's recent reviews (impacted by 2024 free tier restrictions) and suggests genuine customer love rather than passive retention.

Three-tier pricing is clearly published on the website: Hobby (free forever), Growth ($199/month), and Enterprise (custom). Each tier's included limits are explicit: entries, API calls, asset traffic, seats, locales, and environments are all documented. The Enterprise tier requires a sales conversation for pricing, which is standard in the industry. Overage pricing for API calls beyond plan limits is less prominently documented. Overall pricing transparency is better than average for the headless CMS space — the free/Growth/Enterprise structure is straightforward.

The per-call API pricing model can be unpredictable for teams with variable traffic patterns. The $199/month Growth tier is a significant jump from the free Hobby tier — there is no mid-tier option between $0 and $199, which creates a cliff for growing projects. Entry limits and API call caps require monitoring to avoid plan overages. For steady-state enterprise deployments, the pricing model is predictable. For startups scaling through the $0-$200/month range, the gap is a friction point. Compared to Contentful's composites pricing, Hygraph's model is simpler but the free-to-paid cliff is steeper.

Key features require paid plans: Remote Sources (Content Federation with external APIs) requires Growth, SSO and multitenancy require Enterprise, audit logs require Enterprise, advanced content permissions require Enterprise. The Hobby tier is limited to 2 locales (limiting i18n testing), 3 seats (limiting team collaboration), and no remote source connections (limiting Federation testing). The Growth tier at $199/month enables most production features. Feature gating is less aggressive than Contentful (where many features require Premium/Enterprise), but the $0-to-$199 threshold to unlock federation is notable.

Growth tier is available on monthly billing, providing flexibility for teams to scale up/down or cancel. Enterprise contracts are typically annual with volume commitments. Startup program and educational discounts available. No publicly documented exit provisions or switching assistance. Monthly billing on Growth enables trial of the full paid feature set without annual commitment lock-in — a meaningful advantage for evaluating teams.

The Hygraph Hobby tier is free forever (not a time-limited trial) and genuinely useful for small projects: 1000 content entries, 500K API calls/month, 100GB asset traffic, 3 team seats, and 2 locales. Unlike Contentful's November 2024 free tier restriction to non-commercial use only, Hygraph's Hobby tier has no stated commercial use restriction, making it viable for small commercial projects. The limitations (1000 entries, 2 locales, no remote sources, 3 seats) are meaningful for production scale but appropriate for the free tier positioning. This is one of the more generous free tiers in the headless CMS space.

Hygraph's #1 Implementation award from G2 (5 consecutive times) directly validates fast time-to-first-value. Schema setup is accelerated because the GraphQL API is auto-generated from the content model — no manual API endpoint configuration required. First content query can be running in minutes after creating a project and defining a schema. Official quickstarts for Next.js, Nuxt, and other frameworks get you to a working frontend in under an hour. The GraphQL Playground in the Hygraph console enables interactive API exploration without any local setup. Consistently reported as faster to get started than Contentful by developers who have used both.

Typical marketing site: 3-6 weeks. More complex projects with federation and multi-locale: 6-12 weeks. Enterprise implementations: 2-4 months. These timelines are competitive with other headless CMS platforms. The GraphQL schema auto-generation accelerates the data layer setup phase significantly. Content Federation configuration adds complexity for commerce-integrated implementations. Hygraph's faster setup (validated by G2 Implementation awards) generally offsets the GraphQL learning curve for developers new to the technology.

The primary specialist knowledge required is GraphQL — querying, schema design, and mutation patterns. TypeScript experience is highly valuable for type-safe development. A senior React/Next.js developer with GraphQL experience can become productive with Hygraph within a week. Hygraph-specific knowledge (Management API, Content Federation, UI Extensions) develops over time. The GraphQL-specific requirement creates a moderate premium over pure REST/Contentful developers but the premium is offset by the larger pool of GraphQL-knowledgeable developers as GraphQL has become mainstream.

Fully managed SaaS with no infrastructure management required. The license cost is the primary cost driver — no servers, databases, or CDN infrastructure to provision or manage separately. Frontend hosting (Vercel, Netlify, Cloudflare Pages) is separate but standard and platform-agnostic. Asset storage and delivery are included within plan limits. This is the standard SaaS advantage: operational simplicity with predictable infrastructure cost bundled into the subscription.

Minimal operational overhead thanks to the fully managed SaaS model. Security patching, infrastructure scaling, and availability management are all Hygraph's responsibility. The primary operational concerns are API usage monitoring (avoiding overage on plan limits) and content model change management (deploying schema changes across environments). A single developer can handle all Hygraph operational needs part-time. No dedicated DevOps or database administrator required.

Content is exportable via Management API in Hygraph's JSON format — entries, assets, and schema definitions can all be extracted. The GraphQL schema (content model) can be exported and adapted for other platforms. However, Content Federation configurations are Hygraph-proprietary and require redesign on other platforms. Rich Text content is stored in Hygraph's AST format, requiring transformation for most target platforms. UI Extensions are proprietary. The exit cost is moderate — data is accessible but migration to another platform requires meaningful development effort. GraphQL-native architecture creates some lock-in since few target platforms offer equivalent GraphQL delivery without REST.

Core concepts are intuitive: Projects, Content Models (Schema), Entries, Assets, Environments, and Locales. The GraphQL API is auto-generated from the schema, reducing the conceptual surface area compared to platforms where API and content model are managed separately. Union types and Content Federation add moderate complexity for advanced patterns. The schema-first approach means content structure is explicit and queryable — new developers can understand the data shape immediately via GraphQL introspection. Complexity increases significantly when Content Federation is introduced (remote sources, schema stitching concepts), which can be a barrier for less experienced teams.

Good onboarding resources including framework-specific quickstarts (Next.js, Nuxt, Astro, SvelteKit, Remix), an interactive GraphQL Playground in the console for immediate API exploration, and concept guides for content modeling. Video tutorials available on the Hygraph YouTube channel. Sample schemas and starter content can be populated on project creation. Less extensive than Contentful Academy with certification tracks, but the self-serve learning path is adequate for a developer to become productive without external assistance. G2's #1 Implementation award validates that the onboarding experience converts well for real-world projects.

React and Next.js receive first-class treatment with the most complete examples and community resources. Nuxt, Astro, SvelteKit, and Remix are supported with getting started guides. The consumption pattern (GraphQL query in component data fetching) is standard across all frameworks — no proprietary framework-specific abstractions. GraphQL's mainstream adoption (Facebook, GitHub, Shopify use it) means the querying pattern is increasingly familiar to developers. Using standard GraphQL clients (graphql-request, Apollo, urql) means no proprietary SDK concepts to learn.

Official starter templates for Next.js and other major frameworks include schema setup, content seeding scripts, and example pages. Community starters extend the official set on GitHub. The GraphQL content fetching patterns in starters are well-implemented with TypeScript types generated from schema. However, the starter quality and quantity is slightly below Contentful's — fewer framework starters, less polished demo content, and some starters lag behind the latest framework versions. The Next.js starter is the strongest.

Base configuration requires: Content API endpoint URL, a Public Auth Token (for read-only delivery), and optionally Management API token and Personal Access Token for write operations. Environment selection (e.g., Master vs custom environments) is straightforward. Environment variable configuration follows standard conventions. Content Federation adds meaningful configuration complexity (remote source setup, field binding, schema extension configuration) but is optional for simpler implementations. Overall configuration is simpler than Contentful's multi-API-key setup.

Adding new fields is safe and immediate. However, modifying existing field types (e.g., changing a field from Single Line Text to Multi Line Text) on a populated model requires careful handling — the GraphQL schema change can affect existing queries and content. Renaming fields requires updating all GraphQL queries across the consuming application. Circular reference patterns in the schema need careful design. No equivalent of Contentful's 50-field limit per content type. Schema migrations are less tooled than Contentful's migration CLI approach — schema changes are typically done via UI or Management API with less automation scaffolding. Better than Contentful's constraints but still requires care.

Content Preview requires implementing preview mode in the consuming frontend (Next.js draft mode, Nuxt preview mode, etc.) connected to Hygraph's DRAFT content stage. Setup is well-documented but requires meaningful frontend code changes — separate API token with DRAFT content access, preview-aware page routing, and preview mode toggle. The 2025 'Click to Edit' feature improves the preview integration experience by creating a link between preview elements and editor fields. However, Click to Edit requires additional configuration to map frontend elements to editor fields. Not plug-and-play but better than Contentful's preview integration complexity.

GraphQL querying and schema design are the primary specializations required beyond general web development. A developer with React/TypeScript experience and basic GraphQL knowledge can be productive with Hygraph within days. Hygraph-specific knowledge: Management API patterns, Content Federation configuration, content stage workflows, and UI Extension development. The specialization barrier is lower than complex DXP platforms but higher than REST-based CMS platforms for teams without existing GraphQL experience. The GraphQL skill requirement is increasingly mainstream as the technology has been adopted widely.

A team of 2-3 (1 frontend developer + 1 content strategist/author + optionally 1 shared technical oversight) can ship a production marketing site. Solo developers can handle complete implementations for smaller projects. The SaaS model eliminates any backend developer or DevOps requirement for the CMS layer. Larger implementations with Content Federation, multiple environments, multi-locale, and custom UI Extensions need 3-5 people. Consistent with other headless CMS platforms in this dimension.

Content authors can learn the Hygraph editor UI relatively quickly for data entry into structured fields. However, understanding structured content principles — thinking in content types rather than pages — requires onboarding that takes days to weeks for traditional CMS users. Creating new content types and modifying the schema requires developer involvement. The Click to Edit feature reduces the disconnection between the editor and the frontend, improving author experience. Marketing teams need developer support for new page patterns or component types. Similar cross-functional challenges to Contentful but the Click to Edit feature helps close the gap slightly.

The SaaS web app is continuously updated without customer action. SDK upgrades follow semver with migration guides for major versions. The GraphQL API versioning strategy — where the API schema is customer-defined — means Hygraph can evolve platform internals without breaking customer queries. SDK updates introduce no regressions if semver is respected. The primary upgrade surface is the customer's consuming application when using new Hygraph features (e.g., adopting Content Federation requires code changes). Low upgrade burden overall.

SaaS model means Hygraph handles all infrastructure and application security patching. AWS's underlying infrastructure is kept patched by Hygraph's operations team. Customer-side security responsibility is limited to keeping npm dependencies (SDK packages) updated — a standard development workflow. No server-side customer responsibility. Incident response and CVE patching at the infrastructure level are fully managed by Hygraph.

As a younger, faster-moving platform than Contentful, Hygraph has made breaking or forced changes with less historical track record. The rebrand from GraphCMS to Hygraph in 2022 required some endpoint and branding updates. API endpoint migrations (when Hygraph changed domain) required customer action. Feature deprecations have occurred with reasonable notice. The 2025 product velocity (many new features) means the platform is evolving rapidly, which increases the risk of forced migrations over time. Lower confidence given Hygraph's shorter history compared to Contentful or Sanity.

SaaS eliminates all server-side dependency management. Client-side dependencies are minimal: a GraphQL client (graphql-request, Apollo, urql — team's choice) plus optional Rich Text renderer packages. No Hygraph-specific runtime dependencies on the server side. The minimal dependency footprint reduces supply chain risk and maintenance overhead. SDK update frequency is manageable at monthly intervals or less.

Hygraph provides a usage dashboard showing API call consumption, bandwidth usage, and asset storage against plan limits. Status page for platform health monitoring. However, detailed API performance monitoring (latency percentiles, error rates, query-level analytics) requires custom setup in the consuming application or external APM tools. Webhook delivery health requires custom monitoring. Teams need to build their own alerting for plan limit proximity. Not fully hands-off but comparable to Contentful's monitoring posture.

Content hygiene requires manual effort — unpublished referenced entries, orphaned assets, and outdated content accumulate without automated cleanup tooling. Content tagging and classification via Taxonomies helps with organization but requires editorial discipline to maintain. The structured content model helps prevent some hygiene issues (required fields catch empty content) but doesn't prevent reference decay. Large content archives require manual governance processes. Similar to Contentful's content operations burden.

CDN-backed content delivery provides consistent read performance without manual tuning. GraphQL query design is the primary performance lever — well-designed queries with appropriate field selection perform excellently; deeply nested or overly broad queries can be slow. The platform provides no built-in query complexity feedback to developers, but the GraphQL Playground helps identify inefficient queries during development. Asset delivery performance is managed by Hygraph's CDN. No manual performance configuration required for standard deployments.

Hobby tier: community support only (Discord). Growth tier: email/ticket support with business-day response times. Enterprise: dedicated support channel with faster SLAs. Community review data consistently highlights Hygraph's support responsiveness as a positive differentiator — the customer success team is frequently praised in G2 reviews. However, the formal support tier structure means Growth customers don't get premium SLAs. The overall support quality is above average for the platform's tier, driven partly by a smaller, more engaged customer base.

Discord is the primary community channel with reasonable activity and responsive team members. Questions are typically answered within hours during business hours. Stack Overflow coverage is limited but improving. The community is smaller than Contentful's, meaning some niche questions may go unanswered. GitHub issues on Hygraph SDK repositories receive timely responses. The quality of available answers is generally high given the technically engaged community profile, but volume of available community resources is smaller than Tier 1 competitors.

Critical platform bugs are addressed promptly given the SaaS delivery model. Non-critical bugs and feature requests take longer — a typical pattern for SaaS companies. Given Hygraph's smaller engineering team relative to Contentful, response capacity for edge case issues is more limited. The 2025 product velocity (many feature launches) suggests active development, which can sometimes introduce regressions. SaaS delivery means fixes reach all customers immediately once deployed. Customer-reported issues on GitHub are acknowledged but resolution timelines vary.

Landing page creation requires developer-built page templates that content editors populate with structured content. The Click to Edit feature (2025) improves the editing experience by providing visual context while editing — editors can see what they're changing without leaving the form editor entirely. However, there is no native drag-and-drop page builder, no component-level visual editing, and no marketer-self-service page creation without developer involvement for new layouts. Compared to Storyblok (which offers true visual page building) or Contentful Studio (maturing visual editor), Hygraph remains primarily developer-driven for page layout.

No native campaign management capabilities. Scheduled publishing handles time-based content launches. Variants can stage different content versions, but there is no campaign coordination framework, no content calendar, no multi-channel launch management, and no campaign analytics. Marketing teams need a separate martech stack (HubSpot, Marketo, CoSchedule) for campaign management. Hygraph is a content infrastructure platform, not a marketing operations platform — this gap is architectural and by design.

SEO metadata fields (title, description, canonical URL, OG tags, structured data) must be modeled as standard content fields — there are no built-in SEO field types or validation rules. Sitemap generation is a frontend application responsibility. Redirect management requires custom implementation or external tooling. Schema.org structured data must be modeled and rendered manually. Hygraph provides the structural flexibility to implement excellent SEO, but zero out-of-the-box SEO tooling. This is consistent with headless CMS positioning but means marketing teams need developer support for SEO optimization.

No built-in form handling, CTA management, lead capture, or conversion tracking. All performance marketing infrastructure (forms, A/B testing, conversion tracking) requires frontend integration with external tools (HubSpot Forms, Typeform, conversion tracking pixels, etc.). Performance marketing teams will always need a parallel toolset alongside Hygraph. Consistent with the headless CMS architecture philosophy but a significant gap for marketing-led evaluations.

Product content management is a legitimate Hygraph use case strengthened by Content Federation. Teams can model product descriptions, variant content, marketing copy, and rich media as CMS content types, while federating live product data (pricing, inventory, SKUs) from a commerce platform into the same GraphQL endpoint. This hybrid approach — editorial content in Hygraph, transactional data federated from commerce — is architecturally cleaner than competing headless CMS platforms that lack federation. However, there's no purpose-built PIM, no variant SKU management, and no pricing rule engine natively.

No native merchandising features. Category management, promotional content scheduling, cross-sell/upsell content management, search merchandising rules, and visual merchandising tools are all absent. Hygraph is not positioned for merchandising and provides no tooling for it. Commerce use cases require Hygraph to serve as content layer only, with all merchandising logic in a dedicated commerce platform.

Content Federation is Hygraph's differentiating capability for commerce integration. By federating a Shopify, BigCommerce, or commercetools GraphQL API into Hygraph, frontend applications can query product catalog data and marketing content in a single GraphQL request. This is architecturally cleaner than Contentful's commerce marketplace apps (which are UI-level product pickers) — federation happens at the API level, not just the editor UI. The integration requires GraphQL expertise to configure properly and is available on Growth/Enterprise tiers. For developers comfortable with GraphQL federation concepts, this is a genuine competitive advantage for content-commerce composable architectures.

Custom roles with model-level permissions provide granular access control: separate permissions for create, read, update, delete, and publish operations per content type. Public API Endpoints can be scoped to specific content models and stages. SSO integration on Enterprise plans. However, field-level permissions are not supported, and there's no audience-based content visibility (show entries only to specific teams). For intranet/internal content use cases with sensitive data at the field level, this is a gap. For standard internal tool or knowledge base use cases, the access control is adequate.

Content types can model knowledge base articles, FAQs, and documentation effectively. The Taxonomies feature (2025) enables structured classification for content discovery. GraphQL filtering and search work adequately for internal content lookup. However, there's no purpose-built knowledge management workflow: no expiry/archival lifecycle, no approval-required updates for critical knowledge, no knowledge base templates, and the search quality is insufficient for large knowledge repositories without an external search service. Workable for small-to-medium knowledge bases but not purpose-built.

Hygraph is not designed for employee-facing portal experiences. No notification system for content consumers, no social features, no employee directory integration, no personalized content dashboards for end-users, and no portal UX components. Building an intranet on Hygraph is technically feasible via the API but requires building every portal feature from scratch in the consuming application. Teams targeting intranet use cases should evaluate platforms purpose-built for the workplace experience.

Multi-project architecture provides genuine content, schema, and credential isolation between tenants/brands. Each project has independent content models, environments, API tokens, and roles. Organization-level management allows centralized billing and user administration across projects. Enterprise plans offer dedicated infrastructure tenancy (multitenancy vs. shared infrastructure). The project-based isolation is clean for most multi-brand scenarios. Content Federation allows selective data sharing across projects via API composition if needed.

No native cross-project content sharing. Shared components or global content (e.g., global header content, shared legal disclaimers) require either duplication across projects, a dedicated 'global' project with content federated into brand projects via Content Federation, or API-level composition in the frontend. Content Federation partially enables shared content patterns via remote source integration, but configuration is complex and requires active maintenance. For multi-brand architectures needing true shared component libraries at the CMS layer, purpose-built platforms (Contentstack, Sitecore) are better fits.

Organization-level administration provides centralized user management, SSO, and billing oversight. Project-level roles allow brand-specific permission management. Content Workflows enable approval-based publication governance within each project. However, cross-project governance (enforcing brand standards, cross-brand approval workflows, centralized content policies) is not natively supported — it requires process-based governance rather than platform enforcement. The governance model is sufficient for independent brands sharing an Org account but lacks the cross-brand enforcement depth of enterprise DXP platforms.

Multi-project deployments pay per project on Growth ($199/month per project) or negotiate Enterprise pricing across projects. Unlike Contentful's space model (where each space carries full tier pricing), Hygraph's Enterprise multi-project pricing may offer better economies for large multi-brand deployments through volume arrangements. However, public pricing suggests near-linear cost scaling for Growth-tier multi-brand. Content Federation can reduce some duplication costs by sharing content across projects rather than duplicating. The scale economics are better than Contentful for some configurations but still not as favorable as platforms designed from the ground up for multi-brand (Contentstack).

Hygraph takes GDPR compliance seriously as a company with European roots and a significant European customer base. A Data Processing Agreement (DPA) is available for all customers including those on the free Hobby tier, which is notably inclusive. EU data residency is available with data hosted in EU-based AWS infrastructure. Standard Contractual Clauses (SCCs) are included in the DPA. The sub-processor list is publicly maintained. Data deletion mechanisms are available via the Management API for right-to-erasure requests. GDPR compliance tooling is practical and well-documented. A small gap exists around lack of automated DSR workflow tooling (deletion must be implemented via API rather than a self-service DSR portal).

Hygraph does not explicitly offer a Business Associate Agreement (BAA) in public documentation. No healthcare-specific compliance marketing or HIPAA-validated deployment guidance is published. Healthcare organizations could potentially use Hygraph for non-PHI content management (marketing content, educational content), but storing PHI in Hygraph without a BAA would be non-compliant. The platform's SaaS architecture on AWS (which is HIPAA-eligible infrastructure) provides a foundation, but without an explicit BAA offering, healthcare use cases should proceed with caution and direct vendor engagement.

GDPR and EU data protection are well-covered (see 9.1.1). UK GDPR is addressed via IDTA/UK SCCs in the DPA framework. CCPA compliance is covered in the privacy program for US customers. LGPD (Brazil) is addressed in DPA terms. No FedRAMP authorization — US federal government use cases are not supported. No ISO 27017 (cloud security) or ISO 27018 separately. Industry-specific certifications (PCI-DSS, HITRUST) are not independently certified. The regulatory posture covers major commercial enterprise requirements in EU and North America but doesn't reach federal/defense or heavily regulated healthcare requirements.

Hygraph holds SOC 2 Type 2 certification covering Security, Availability, and Confidentiality Trust Service Criteria. The certification is listed on the hygraph.com/security page and available to enterprise customers under NDA. Annual audit cadence maintains the certification. The SOC 2 Type 2 scope covers the Hygraph platform, content delivery infrastructure, and management systems. This is the most important certification for enterprise software procurement and Hygraph meets the standard. The certification was a deliberate investment as the company moved upmarket to enterprise customers.

ISO 27001 certification for infrastructure is confirmed in Hygraph's security documentation. The scope appears to cover the infrastructure management layer (AWS-hosted environment and related operational processes). ISO 27018 (cloud privacy for PII) is not separately documented — this is a gap compared to Contentful which holds both ISO 27001 and ISO 27018. The ISO 27001 infrastructure certification demonstrates baseline information security management practices. Certificates are listed on the security page but less prominently detailed than Contentful's certifications.

SOC 2 Type 2 and ISO 27001 are the primary certifications. The underlying AWS infrastructure inherits AWS's extensive certification portfolio (ISO 27017, PCI DSS, HIPAA-eligible, FedRAMP Moderate for AWS services). No independent PCI DSS certification for Hygraph itself. No Cyber Essentials Plus, C5 (Germany), or ENS (Spain) documented. No CSA STAR Level 2 or Level 1 documentation. The additional certification portfolio is adequate for commercial enterprise procurement but limited for heavily regulated or government use cases. As Hygraph grows upmarket, the certification portfolio expansion will be important to watch.

EU and US data residency choices are available. EU projects are hosted in EU-based AWS regions, US projects in US AWS regions. Contractual data residency commitments are included in enterprise agreements. CDN delivery distributes cached content globally via CDN edge nodes — customers requiring strict data residency must factor in CDN cache distribution. No multi-region active-active setup beyond the binary EU/US choice. For most European enterprises, EU residency with contractual commitments is sufficient. For organizations with strict national data sovereignty requirements (government data), the limited regional choice may be constraining.

Full content export is available via the Management API — all entries, assets, and schema definitions can be programmatically extracted. Post-termination data retention and deletion policies are documented in the DPA. Right-to-erasure requests can be fulfilled via API-based content deletion (specific entries) or project deletion (bulk). There is no self-service DSR workflow portal — deletion must be implemented via API or UI operations, which requires developer involvement. The data lifecycle mechanisms are technically complete and compliant but lack the user-friendly DSR tooling that some larger platforms provide.

Audit logs covering content operations (create, update, publish, unpublish, delete) and administrative actions are available on Enterprise plans. Content operation logs are accessible via the Hygraph console and Management API. Log retention periods and SIEM integration options are not prominently documented for Hygraph — this is a gap vs. Contentful's documented 90-day log retention with API polling for SIEM integration. For compliance reporting, audit logs cover the essential content lifecycle events but may require custom tooling to extract into compliance reporting formats.

Hygraph's web application targets WCAG 2.1 AA compliance for the content editing interface. The field-based editor supports keyboard navigation for basic operations. Screen reader compatibility for standard form fields is generally functional. However, complex UI components (the schema builder, rich text editor, asset library) have accessibility gaps typical of complex web applications. The Click to Edit visual preview interface introduces more complex interaction patterns that are harder to make fully accessible. No formal VPAT or ACR is publicly published for procurement evaluation.

Hygraph does not have a prominently published VPAT (Voluntary Product Accessibility Template) or ACR (Accessibility Conformance Report) for the authoring environment. No Section 508 formal conformance statement. No ATAG 2.0 formal assessment. Accessibility commitment documentation is minimal compared to enterprise platform standards. For procurement evaluations where VPAT documentation is required, Hygraph's current documentation would be insufficient. This is an area where maturing platforms eventually need to invest as they move upmarket to regulated enterprise customers.