Book a call

Migration

WordPress to custom code

Content stays in WordPress behind the new site or leaves as XML or JSON. Design and plugins are rebuilt in code, and a redirect map protects search.

Trusted by teams from pre-seed to the S&P 100

  • Morse Micro
  • Lumos
  • Superpower
  • Managed
  • Keeyu
  • Crimson Education
  • Trusst AI
  • Kaizn
  • Everlab
  • Startmate

What moves, and what gets rebuilt

Each part of the site, what it becomes, and whether it comes across, needs converting or is rebuilt.

On WordPressOn custom code
  1. WordPressPosts, pages and custom post types in the WordPress database

    Posts and pagesNeeds converting

    custom codeFetched from WordPress over the REST API, or converted into files in the code or another CMS

  2. WordPresswp-admin, with roles, scheduling and a revision on every save

    EditingNeeds converting

    custom codeThe same wp-admin if WordPress stays behind the site; otherwise a developer or the new CMS

  3. WordPressA theme, the block editor or a page-builder plugin drawing each page

    Design and templatesRebuilt

    custom codeLayouts and components written in Next.js or Nuxt; nothing in the theme carries over

  4. WordPressThe Media Library, each file with its own URL and alt text

    Images and filesNeeds converting

    custom codeServed from WordPress if it stays; otherwise downloaded, moved to the new host and relinked

  5. WordPressPermalinks from Settings, Permalinks, with category and tag bases

    URLs and redirectsNeeds converting

    custom codeRoutes written to match the old paths, and a permanent redirect for each one that changes

  6. WordPressTitles, canonicals and /wp-sitemap.xml from core, descriptions from an SEO plugin

    Search settingsRebuilt

    custom codeMetadata, canonical tags, sitemap and robots files written by the developers

  7. WordPressA form plugin, with its entries stored in the WordPress database

    FormsRebuilt

    custom codeForms in code that send to email, a CRM or a database; old entries exported first

  8. WordPressPlugins for SEO, caching, security, redirects, search and the rest

    PluginsRebuilt

    custom codeNo plugins: each job becomes code in the site, a setting on the host or a separate service

Moving from WordPress to custom code, step by step

What WordPress lets out, whether it stays behind the new site, how content maps to routes, the redirects and search tags, the checks, and who should stay.

Why teams move from WordPress to custom code

In this guide, custom code means a site written by developers in a framework such as Next.js or Nuxt and deployed like any other application. There is no theme and there are no plugins. The site runs the code your team put there.

The strongest reason is the product. When the marketing site has to use the same components, the same design system or the same login as the app, a coded site can share them with the app’s codebase. Teams whose developers already work in React or Vue every day usually want the site reviewed and released the same way as everything else they ship.

The second reason is the plugin list. Each plugin is another author’s code, its security flaws are that author’s to fix, and its automatic updates stay off until an administrator turns them on one at a time. A coded site still has dependencies, but your developers pick them and update them together.

Some reasons do not hold up. Next.js and Nuxt render on the server by default, so crawlers get HTML, but a WordPress theme serves HTML too, and a framework on its own will not lift rankings. A slow WordPress site is often fixed by better hosting and fewer plugins. Swapping WordPress upkeep for framework upkeep helps only if someone does the upkeep: Nuxt 3 reached end of life on 31 July 2026, and a site left on it gets no security patches.

If the people who publish live in wp-admin and nobody on the team writes code, read the chapter on when to stay before going further.

WordPress vs custom code

What WordPress lets out, and what code takes in

WordPress lets content out two ways. Tools, Export writes one XML file in its WXR format, holding posts, pages, comments, custom fields, categories, tags, custom taxonomies and users, or only the posts or pages if you choose. The REST API serves the same kind of content as JSON from the live site, at /wp-json/wp/v2/posts, /pages, /media and /users. WordPress.com’s export guide says the file leaves out the theme and plugins, and the design is written again in code whichever way the content leaves.

For this move the REST API is usually the better source, because a script can page through it. It returns at most 100 records a request, and the X-WP-Total and X-WP-TotalPages headers tell you how many requests a full copy takes. It returns published posts unless you ask for other statuses. For requests that sign in, WordPress has shipped Application Passwords since 5.6: make one under Users, Edit User, and send it over HTTPS.

Custom post types are the usual gap. A type gets a REST route when the code that registers it sets show_in_rest to true, so request each type once before you plan around it. WordPress recommends registering them in a plugin, which is often where that setting has to be changed.

Request one post and read the whole response before anyone designs a template. The featured image and the author arrive as ID numbers you look up, the categories and tags as lists of term IDs, and the body in whatever state the editor and the plugins left it.

A coded site has no import screen. It takes in whatever its developers write code to read: the JSON when a page is built or requested, or files made once by a conversion script.

Keep WordPress behind the site, or take the content out

This decision sets the shape of the rest of the move, and it comes down to who edits. There are three answers.

WordPress stays as the CMS. Editors keep wp-admin, with its roles, scheduling and revisions, and the coded site fetches content from the REST API. Two jobs the theme used to do become the developers’. Previews: in Next.js, Draft Mode shows an editor a draft on the real site, through a route the preview link opens with a shared secret, so WordPress’s preview link has to point at it. Publishing: pages are cached, so a new post appears once the cache for its address is refreshed, usually by code in WordPress that calls a route on the site running revalidatePath. WordPress still needs its hosting, updates, backups and certificate, so you now look after two systems.

The content moves into the code. Posts become Markdown or data files in the repository, and every change is a commit and a deploy. There is no CMS to patch, and on Vercel a bad release can be rolled back to an earlier deployment. Every edit goes through a developer. This site works this way: it is built in Nuxt, hosted on Vercel, and has no CMS, which suits us because the people who publish it are developers.

The content moves to another CMS. Editors learn a new tool, and its roles and scheduling are that product’s, so compare them with what wp-admin gives you today. We have not checked any CMS product for this guide, so none is named here.

Keep WordPress if editors publish often and are happy where they are. Move the content into the code if developers publish and a handful of posts change in a year. Choose another CMS when you want WordPress gone and still have editors.

What a headless CMS isWhat a CMS is

How WordPress content maps to routes and files

On a coded site each content type becomes a route with a template, and its fields become the data the template reads. Map them type by type:

  • Posts become a dynamic route, such as app/blog/[slug]/page.tsx, or app/[slug]/page.tsx if the posts sat at the root. Keep each WordPress slug exactly as it was.
  • Pages with their own layouts become routes of their own. Pages that share one template can come from a single catch-all route. Each page’s parent and menu order come through the REST API, so a nested page can keep its path.
  • Categories and tags become /category/[slug] and /tag/[slug], each listing its posts. If you cut tags that were used once, redirect the ones you cut.
  • Custom post types, such as case studies or team members, each become a route and a type, with their custom fields as typed properties.
  • Images come from each media item’s source_url, with its alt text going to the alt prop of the image component. If the content leaves WordPress, download every file, move it to the new host and rewrite each reference in the post bodies.

Post bodies are the untidy part in every case. A shortcode is a WordPress-specific code in square brackets, drawn by the plugin that made it, and a coded site draws none of them. Block editor and page-builder markup arrive as HTML your components have to style or replace. Search the bodies for an opening square bracket and for the builder’s class names, and decide what each becomes. Comments have nowhere to go unless you add a comments service, so keep the useful ones in the post or let them go.

No plugin comes with you. List each active one and the job it does: the SEO plugin’s titles and descriptions become metadata in each layout and page, and its structured data a JSON-LD script tag. A redirect plugin’s list goes into the redirect map. A form becomes a Server Action that sends each entry to email, a CRM or a database, once the old entries are exported. Caching, security and certificate plugins have no replacement to write, since on Vercel the infrastructure and certificate are the host’s and the code and data are yours. Search, multilingual and membership plugins each become code or a separate service, and WooCommerce is a project of its own.

Shopify vs custom code

The order of work

We run the move in this order, and it holds when your own developers do it:

  • Inventory. Pull every URL from /wp-sitemap.xml or the SEO plugin’s sitemap, add the pages that bring visits or links from analytics and Search Console, and write down the permalink setting.
  • Redirect map. Put the new path beside each old one in a spreadsheet. On this move most rows keep the same path; mark those as routes the build has to answer.
  • Content model. Decide where the content lives, write a type for each kind of content, and pull ten posts through the REST API or the conversion script to test every field.
  • Rebuild. Build the layouts, components and routes on a preview deployment, with the metadata, canonical tags, sitemap and robots files written alongside them.
  • Content. Run the full conversion or connect the site to the production WordPress, then fix the shortcodes, the builder markup and the image links.
  • Checks. On the preview, request every row of the redirect map, check the status code of a missing page, send each form and read the head tags of each template.
  • Launch. Point the domain at the new host, confirm the certificate, request the redirect map again on the live domain and submit the new sitemap in Search Console.
  • Watch. Read Search Console’s not found report and the traffic to the top old pages for weeks after launch, and add redirects for whatever the map missed.

How we run a website project

Checks before you switch the domain

Work through these on the preview deployment, and the redirect and status checks again on the live domain:

  • The count of posts, pages and each custom post type matches the X-WP-Total header for each in WordPress.
  • Every row of the redirect map lands on the right page in one hop, with a 308 or 301.
  • Each address that keeps its path returns 200 at exactly that path, with the trailing slash WordPress used, or without it.
  • An address with no replacement returns a 404 in the response headers. Next.js keeps a 200 once a page has started streaming, so read the status code itself.
  • View source on each template shows its own title and description and one canonical tag pointing at the live domain.
  • /sitemap.xml lists every live page and none that redirect, and /robots.txt names it and blocks nothing it should not.
  • A search of the published pages for an opening square bracket finds no shortcodes left over.
  • Images load with alt text, and none still point at the old WordPress host unless WordPress is staying.
  • Each form delivers a test entry to where it should go, and a named person receives it.
  • Analytics and tag scripts, added once in the root layout, record a visit.
  • If WordPress stays: it sits at its own address with Discourage search engines ticked, which removes its sitemap and adds a noindex tag, and publishing a post updates that page and the sitemap on the live site.
  • A full backup of the WordPress files and database, the old form entries and the comments worth keeping are saved somewhere you control.

B2B website redesign checklist

When to stay on WordPress

For many sites this move costs more than it returns. Stay on WordPress, and fix what is wrong with it, if:

  • Editors publish every day and nobody on the team writes code. Every layout change on a coded site needs a developer, and with the content in the code, so does every post.
  • The site runs on plugins that do real work, such as memberships, courses, bookings, a directory or WooCommerce. Each one becomes a build of its own.
  • The site is in several languages through a plugin. The language routes, the translations and the hreflang tags all become code.
  • The complaint is speed or upkeep. A better host, fewer plugins and a named person on updates cost far less than a rebuild.
  • You want marketers to lay out new pages themselves. A visual builder suits that better than code does.
  • Nobody will own the framework after launch. Next.js gives the previous major version security fixes for two years from its release, and a site left behind loses them as an old WordPress does.
  • You would keep WordPress behind the site only to avoid moving the content. You then run WordPress and a coded site, and pay to keep both.
  • The launch date is weeks away. Routes, metadata, redirects, the sitemap and forms are all written from nothing.

WordPress to Webflow

What decides the time and the cost

The layouts take most of the time, because each becomes components and a route. Ten landing pages built from three layouts are quicker than five that share nothing. The blog is one template and one list, however many posts it holds.

Next comes where the content lives. Keeping WordPress adds the API work, previews, the refresh on publish and a second system to keep up. Moving the content out adds a conversion script, a pass through every post body and the move of every media file. Plugins with logic of their own add the most, since each becomes code or a service.

Our websites start from $15,000, and most take four to eight weeks. There is no separate migration price: we price the move as a website project, on the page system, content work, integrations, publishing requirements and migration complexity, and agree the scope and price before we start. We prefer to build custom sites in Next.js and Nuxt, and we work on any platform.

If your own developers do the move, the costs are their time, the new host’s plan and, if WordPress stays behind the site, the WordPress hosting you keep paying for.

What a B2B website costsPricingHow we build in code

Vendor details were checked against the documentation for WordPress, Next.js and Vercel on 15 November 2026. Frameworks change between versions, so read the current docs for yours before you start.

Moving from WordPress?

Short answers, from the guide above.

  1. Yes. WordPress has a REST API built in, so a Next.js site can fetch posts, pages and media as JSON while editors keep working in wp-admin with the same roles and scheduling. The developers then build two things WordPress did for free: a preview of drafts, and a way for a published post to appear on the site. WordPress still needs its own hosting, updates and backups.

  2. Nobody can promise every position holds, and some movement in the weeks after launch is normal. We inventory valuable URLs, plan redirects and check canonicals, indexability, content and internal links, then monitor after launch. On a coded site each of those is written by the developers, from the routes and redirects to the canonical tags, sitemap and robots.txt. None of it exists until someone writes it.

  3. Most of our website builds take four to eight weeks, and we plan and price a migration as a website project. The number of distinct layouts decides most of it, because each becomes a component. Keeping WordPress behind the site adds the preview and publishing work. Taking the content out adds a conversion script and a check of every post. Plugins with logic of their own add the most.

  4. Yes, every one of them if you want. The developers write each route, so a post at /post-name/ can stay at that path and so can /category/name/. Two settings catch people out: Next.js removes trailing slashes unless trailingSlash is set to true, and a permanent redirect in its config sends a 308 status. Any address that does change needs its own redirect.

  5. That depends on where the content lives. If WordPress stays behind the site, editors keep wp-admin and see little change. If the content moves into files in the code, a developer makes and publishes each change. If it moves to another CMS, editors learn that tool, with whatever roles and scheduling it offers. Decide this first, because it shapes the build.

Planning this move?

Tell us where it is now and where it is going. We’ll say what we’d keep, what we’d rebuild and how long it takes.

Most teams start with a call, then a sprint or an audit.

Book a call
  • Angus
  • James
  • Naiya
  • Lilian
  • Luca
  • Minh
  • Jorge
  • Toffee

The people you’d work with, from the first call to launch