A monolithic WordPress slows down at 5,000 publications? Every click in the admin takes 3 seconds? Editors lose patience, and PHP templates prevent modern design. The optimal solution involves adopting a headless content management architecture. We handle turnkey migrations, preserving SEO rankings and reducing Time to Market. For the frontend, we use Next.js or Nuxt — SSR/SSG, lazy loading, Core Web Vitals optimization. Content managers work in a familiar interface, while developers freely choose their tech stack. Our team has completed over 150 headless CMS migrations with 8+ years of experience, ensuring smooth transitions.
Headless CMS separates content management from presentation. Migration requires careful planning: content inventory, mapping post types, API configuration, and a parallel-running period.
Assessment Before Starting
Before selecting the target CMS, we audit the current setup: inventory custom post types, ACF fields, used plugins (WooCommerce, Events Calendar), content team's skill level, licensing budget, and requirements for drafts and previews. Based on this, we choose the platform: Strapi for self-hosted, Contentful for SaaS with a powerful editor, or Sanity for flexible schema. After migration, hosting and licensing costs drop by up to 60% — typical savings range from $2,000 to $5,000 per year. For a small site (up to 500 posts), the typical migration investment is $5,000–$10,000, while annual hosting savings are $2,000–$5,000.
How to Choose a Headless CMS?
Comparison of popular platforms:
| Criterion | Contentful | Sanity | Strapi | KeystoneJS |
|---|---|---|---|---|
| Hosting | SaaS | SaaS/Self | Self | Self |
| Pricing | Enterprise | Starter | Open Source | Open Source |
| Editor | Good | Excellent | Basic | Basic |
| API | REST + GraphQL | GROQ + GraphQL | REST + GraphQL | GraphQL |
| Media | CDN included | CDN included | Own storage | Own storage |
Strapi's community is 3 times larger than KeystoneJS, with more ready-made plugins. GraphQL API allows selecting only needed fields, reducing data transfer by 2–3 times compared to REST — a significant improvement over the traditional REST approach. Headless CMS licensing costs are typically 2–3 times lower than enterprise solutions. On Next.js with headless CMS, LCP is 2–3 times lower than on classic WordPress, as confirmed by Core Web Vitals measurements. Next.js at the frontend reduces Time to Interactive by 2–3 times compared to WordPress with heavy plugins. The WordPress GraphQL API (via WPGraphQL) can be used to expose data, but migrating to a dedicated headless CMS yields even better performance.
Stage 1: Audit and Content Mapping (1–2 weeks)
Inventory existing content:
# Export from WordPress via WP-CLI
wp export --post_type=post,page,product --status=publish --path=/var/www/html
# Analyze ACF fields
wp acf field-group export --group_id=all --output=json > acf-fields.json
# Statistics by type
wp post list --post_type=post --format=count
wp post list --post_type=page --format=count
Mapping WordPress → target CMS:
# mapping.yaml
wordpress_types:
post:
target: blogPost
fields:
post_title: title
post_content: body (RichText)
post_excerpt: excerpt
post_date: publishedAt
_thumbnail_id: featuredImage (Asset)
categories: categories (Reference[])
tags: tags (Reference[])
acf.seo_title: seoTitle
acf.seo_description: seoDescription
product:
target: product
fields:
post_title: name
_regular_price: price (Number)
_stock_qty: stock (Number)
product_cat: categories
acf.gallery: gallery (Asset[])
How to Migrate Content Without Loss?
We write TypeScript scripts that retrieve posts, media, and relations via the WP REST API, then send them to the new CMS via Management API. The code handles rate limiting, converts HTML to Markdown, and uploads images.
// scripts/migrate-from-wp.ts
import axios from 'axios';
import * as contentful from 'contentful-management';
import TurndownService from 'turndown';
const turndown = new TurndownService({ headingStyle: 'atx' });
const cmaClient = contentful.createClient({ accessToken: process.env.CMA_TOKEN! });
async function migratePosts() {
const space = await cmaClient.getSpace(process.env.SPACE_ID!);
const env = await space.getEnvironment('master');
let page = 1;
while (true) {
const { data: posts } = await axios.get(
`${WP_URL}/wp-json/wp/v2/posts?per_page=100&page=${page}&_embed`
);
if (!posts.length) break;
for (const wpPost of posts) {
await migratePost(env, wpPost);
await delay(200);
}
page++;
}
}
async function migratePost(env: any, wpPost: any) {
const featuredImageUrl = wpPost._embedded?.['wp:featuredmedia']?.[0]?.source_url;
let imageAsset;
if (featuredImageUrl) {
imageAsset = await uploadAsset(env, featuredImageUrl, wpPost.title.rendered);
}
const entry = await env.createEntry('blogPost', {
fields: {
title: { 'en-US': wpPost.title.rendered },
slug: { 'en-US': wpPost.slug },
body: { 'en-US': turndown.turndown(wpPost.content.rendered) },
excerpt: { 'en-US': wpPost.excerpt.rendered.replace(/<[^>]*>/g, '') },
publishedAt: { 'en-US': wpPost.date },
...(imageAsset && {
featuredImage: { 'en-US': { sys: { type: 'Link', linkType: 'Asset', id: imageAsset.sys.id } } },
}),
},
});
await entry.publish();
console.log(`Migrated: ${wpPost.title.rendered}`);
}
Stage 2: Configure the New CMS (1 week)
Create Content Types in the target CMS exactly per the mapping. Set up validations, localization, roles. This stage runs in parallel with the audit.
Stage 3: Migration Script (1–2 weeks)
The code above is an example for Contentful. We write similar scripts for Strapi via its REST API or for Sanity via mutation API.
Stage 4: Migrate Media Files
// Download and upload all WP media files
async function migrateMedia() {
const { data: media } = await axios.get(`${WP_URL}/wp-json/wp/v2/media?per_page=100`);
for (const item of media) {
const asset = await env.createAsset({
fields: {
title: { 'en-US': item.title.rendered },
description: { 'en-US': item.alt_text },
file: { 'en-US': {
contentType: item.mime_type,
fileName: path.basename(item.source_url),
upload: item.source_url,
}},
},
});
await asset.processForAllLocales();
await asset.publish();
mediaIdMap[item.id] = asset.sys.id;
}
}
Stage 5: Parallel Run and Switchover
- Deploy new frontend on staging with real data.
- Conduct design review with content team.
- Set up automatic synchronization from WordPress to new CMS during transition.
- DNS switch during low-traffic period.
- Decommission WordPress after 2–4 weeks of stabilization.
Typical Timelines
| Stage | Small site (<500 records) | Medium (500–5000) | Large (5000+) |
|---|---|---|---|
| Audit & mapping | 1 week | 1–2 weeks | 2–4 weeks |
| CMS setup | 3–5 days | 1 week | 1–2 weeks |
| Migration script | 1 week | 1–2 weeks | 2–4 weeks |
| Testing | 3–5 days | 1 week | 2 weeks |
| Launch | 1 day | 1–2 days | 1 week |
| Total | 4–6 weeks | 6–10 weeks | 3–5 months |
Common Migration Mistakes
- Site downtime due to lack of parallel operation.
- Broken relationships between records from incorrect mapping.
- Performance drop from unoptimized GraphQL queries.
- Incorrect media handling (duplicates, lost alt tags).
We address all these risks during the testing phase.
What's Included
- Audit of current architecture and content mapping.
- Configuration of target CMS (Content Types, roles, localization).
- Migration scripts for content and media.
- Automatic sync setup for transition period.
- Frontend development on Next.js/Nuxt with Core Web Vitals focus.
- DNS switchover and post-migration support.
- Documentation and training for the content team.
We guarantee preservation of SEO positions, provided our recommendations are followed. Headless architecture with Core Web Vitals optimization improves user experience significantly. Our frontend leverages SSR and SSG (headless) for optimal performance. We'll assess your project in 2 days. Contact us for a preliminary audit. Get a consultation — we'll find the optimal architecture and timeline.