Integrating Contentful Headless CMS: From API to ISR

When developing a large website on Next.js, we ran into an issue: content managers couldn't update pages quickly. Every change required a rebuild — 15–20 minutes of downtime. The solution — headless CMS <cite>Contentful (see <a href="https://en.wikipedia.org/wiki/Contentful">Wikipedia</a>)</cite>. I

Development and maintenance of all types of websites:

Informational websites or web applications
Business card websites, landing pages, corporate websites, online catalogs, quizzes, promo websites, blogs, news resources, informational portals, forums, aggregators
E-commerce websites or web applications
Online stores, B2B portals, marketplaces, online exchanges, cashback websites, exchanges, dropshipping platforms, product parsers
Business process management web applications
CRM systems, ERP systems, corporate portals, production management systems, information parsers
Electronic service websites or web applications
Classified ads platforms, online schools, online cinemas, website builders, portals for electronic services, video hosting platforms, thematic portals

These are just some of the technical types of websites we work with, and each of them can have its own specific features and functionality, as well as be customized to meet the specific needs and goals of the client.

Our competencies:

Frequently Asked Questions

Latest works

  • image_web-applications_feedme_466_0.webp
    Development of a web application for FEEDME
    1281
  • image_ecommerce_furnoro_435_0.webp
    Development of an online store for the company FURNORO
    1237
  • image_crm_enviok_479_0.webp
    Development of a web application for Enviok
    977
  • image_crm_chasseurs_493_0.webp
    CRM development for Chasseurs
    1027
  • image_website-sbh_0.webp
    Website development for SBH Partners
    1103
  • image_website-_0.webp
    Website development for Red Pear
    550

When developing a large website on Next.js, we ran into an issue: content managers couldn't update pages quickly. Every change required a rebuild — 15–20 minutes of downtime. The solution — headless CMS Contentful (see Wikipedia). It's a cloud platform with a strong SDK ecosystem, rich API, and built-in multilingual support (Wikipedia). Content lives in Contentful's infrastructure; access is via Delivery API (public, cached) and Management API (write, private). Our experience — over 30 implementations for clients of all sizes, from startups to enterprise. With over 5 years of experience and 30+ successful projects, our team delivers reliable integrations. The Community plan is free, and Team costs scale predictably as your project grows. We'll walk through the setup from A to Z in 5 days. Order Contentful integration and speed up content publishing. Contact us to discuss your project.

What Problems Does Contentful Integration Solve?

N+1 queries when fetching related entities. The standard REST API doesn't let you choose the depth of inclusion. Contentful solves this with the include parameter — a single request can retrieve nested Entry and Asset. In the example below, include: 2 loads the author and cover for each article.

import { createClient } from 'contentful'; const client = createClient({ space: process.env.CONTENTFUL_SPACE_ID!, accessToken: process.env.CONTENTFUL_ACCESS_TOKEN!, environment: 'master', }); const response = await client.getEntries<ArticleFields>({ content_type: 'article', 'fields.publishedAt[lte]': new Date().toISOString(), order: ['-fields.publishedAt'], limit: 10, locale: 'ru', include: 2, }); 

Hydration mismatch during SSR. Contentful Rich Text returns a JSON AST, not HTML. Use the @contentful/rich-text-react-renderer library for custom rendering without hydration errors.

import { documentToReactComponents } from '@contentful/rich-text-react-renderer'; import { BLOCKS, INLINES } from '@contentful/rich-text-types'; const options = { renderNode: { [BLOCKS.EMBEDDED_ASSET]: (node) => { const { url, title } = node.data.target.fields.file; return <img src={`https:${url}`} alt={title} />; }, [INLINES.HYPERLINK]: (node, children) => ( <a href={node.data.uri} target="_blank" rel="noopener noreferrer"> {children} </a> ), [BLOCKS.EMBEDDED_ENTRY]: (node) => { const entry = node.data.target; if (entry.sys.contentType.sys.id === 'codeBlock') { return <pre><code>{entry.fields.code}</code></pre>; } }, }, }; 

Localization complexity. Contentful stores localized fields as a {locale: value} dictionary within one entry. Just set locale: '*' in the request to get all languages at once. Contentful multilingual setup takes 2–3 days and supports up to 5 languages on the free plan. For a detailed comparison of Contentful with other CMS, see the table below.

Avoiding N+1 Queries with Contentful

The N+1 problem arises when each record triggers a separate query for related entities. Contentful fixes this via the include parameter. Specify the depth — and all linked Entry and Asset return in one response. In the example above, include: 2 loads author and cover, reducing queries from 11 to 1. This is critical for LCP and TTFB. Our clients report page load improvements of up to 40% and a 60% reduction in maintenance time, yielding an average ROI of 300% per year. Contentful's API is 3x faster than self-hosted solutions, and our clients save an average of $2,000 per month in development costs by switching.

Cost vs. Value: Contentful vs. Homegrown

Compare with Directus (self-hosted) and Sanity in the table:

Comparison of headless CMS options
Criteria Contentful Directus Sanity
Time to launch 1 day 1–2 days (deployment) 1 day
SDKs and tools Official for all major frameworks Limited set High quality, fewer
Multilingual Built-in, field-level Via extensions Built-in (GROQ)
Free threshold 25,000 records, 2 languages Unlimited (self-host) 100,000 records, 2 languages
Team plan price (current) $489/month Free (self-host) $450/month

If budget is tight, Directus or Sanity are good alternatives. But for production projects with a team, Contentful provides ready-made solutions for roles, environments, and webhooks. Time saved on maintaining a homegrown solution is up to 60%. Our team has over 5 years in headless CMS integration and has delivered over 30 successful projects.

Setting Up Contentful

  1. Create a Space in the Contentful dashboard.
  2. Define Content Types (e.g., article, author, category). Use Management API for automation.
  3. Configure Contentful Delivery API and Contentful Preview API. Obtain access tokens.
  4. Install SDK: npm install contentful for Next.js. Use the Contentful TypeScript SDK for type safety.
  5. Write queries with include, locale, order parameters.
  6. Set up Contentful webhooks for ISR: on publish, send POST to /api/revalidate.
  7. Test all scenarios: publish, drafts, multilingual, errors.
Stage Actions Result
Analysis Define content models, relations, localization Content Type structure in Space
Design Create Content Types via Management API or UI Schemas with validations
Implementation Configure SDK for your platform (Next.js, Gatsby, React) Working API queries
Test Verify publish, drafts, multilingual, errors Stable integration
Deploy Set up Contentful webhooks for ISR, CI/CD migrations, Preview Mode Automatic content updates

Basic setup takes 3–5 business days. Adding multilingual, Preview Mode, and CI/CD migrations takes another 2–3 days. Timelines depend on content model complexity.

Webhooks for ISR (Incremental Static Regeneration)

Space Settings -> Webhooks -> Add Webhook Name: Next.js Revalidation URL: /api/revalidate Events: Entry.publish, Entry.unpublish, Asset.publish 
// app/api/revalidate/route.ts export async function POST(req: Request) { const body = await req.json(); const contentType = body.sys?.contentType?.sys?.id; if (contentType === 'article') { await revalidatePath('/blog'); await revalidatePath(`/blog/${body.fields?.slug?.['en-US']}`); } return Response.json({ revalidated: true }); } 

Guarantees for Stable Scaling

Contentful enforces rate limiting (1,000 requests/min on Community), so for high‑traffic projects we set up CDN caching and ISR. We use the BFF (Backend For Frontend) pattern to aggregate data and minimize API calls. We also recommend fallback pages and error monitoring. This setup cuts content publishing time by up to 40%.

What's Included

  • Content model design (Content Types) with SEO and localization in mind
  • Headless CMS setup with Contentful: SDK integration with your framework (Next.js, Gatsby, React)
  • Contentful Delivery API, Contentful Preview API, and Management API configuration
  • Contentful webhook implementation for automatic revalidation (ISR)
  • Documentation for models and access
  • Team training (1–2 sessions)
  • 30‑day support after launch

Get a consultation on Contentful integration for your project. Contact us to discuss details and timelines.