X to Drupal, by QED42

Your website, modernised on a Drupal CMS you own, ready for LLMs

Modernising a website in 2026 means AI inside the CMS, digital sovereignty, an open architecture and readiness for AI agents. X to Drupal is the QED42 harness that gets a finished website there by replatforming it to Drupal 11: the same design, a real content model, AI capabilities wired in, and a handover your content team can act on without a training week. The result is an exportable Drupal CMS for any Drupal 11 host, with no vendor lock-in.

We proved it on our own site first.

Leave your work address and we will come back with what a move to Drupal would involve on your site. Work email, no drip sequence, unsubscribe from any message.

From the qed42.com replatform: 569 article bodies moved across, 2,007 images brought into Drupal media, zero custom modules carrying the site.

The acceleration

What acceleration looks like with X to Drupal

Acceleration here means one thing: the transcription work of a replatform, reading every page and rebuilding it on Drupal, is done by the harness run, in days. The decisions, the review and the launch stay with people, and they set the pace of everything around the run. Pick the shape closest to your site.

Our own site, measured rather than estimated. Webflow before, Drupal 11 after, and the side-by-side comparison further down this page is the result.

646 pages17 page templates7 forms

Harness run
About 4 days
Live on Drupal
3 to 5 weeks

From kickoff to go-live, with your team's review and the launch window inside it.

What the harness accelerates

On every run:

  • Reading the site: every page address, found from the sitemap and a crawl of the navigation, then the design, the components that repeat and the content underneath them.
  • The content model: a content type for each repeating template, pages built from typed components, Views, taxonomies, and each form rebuilt as a Drupal Webform.
  • The theme: a Drupal 11 theme that reproduces your design, with its design tokens and your own fonts.
  • The content move: the content of every public page and its images into Drupal, with existing page addresses kept as they are and the source site's own redirects carried across.
  • The wiring: metadata, structured data and an XML sitemap, Drupal's AI layer set up against your own provider key, and an llms.txt map of the site.
  • The checks: every template compared with the live site at desktop, tablet and phone widths, and at every breakpoint your design declares.
  • The runbook: the content model in plain English for your content team, with every component shown populated.

What moves at your team's pace

These take the time they need, and the plan gives them room:

  • Decisions: what to keep, what to retire, and sign-off on the content model.
  • Review: your team's review of the delivered site, on your own pages.
  • Content that changes during the project: a second pass close to cutover lists what was published, changed or removed since the snapshot.
  • Go-live: environments, DNS cutover, a rollback plan, then two to four weeks on call.
  • Integrations, custom functionality, analytics set-up and hosting: scoped separately. See what a replatform includes

The quality of the final build

The measure is the finished build. The harness applies the same modelling rules to every component and every page, each run ends with the new site checked against the live one, and people review the result before it goes live.

See the before and after

None of these is your site. Get in touch and we will come back with what replatforming would mean for yours.

The proof

We moved our own site first

qed42.com ran on Webflow. We pointed X to Drupal at it and shipped the result, and qed42.com now serves that Drupal 11 site. The Webflow original is gone from the address, so the captures below are where the two can still be put next to each other. There is no averaged parity score, because a single number flatters the easy pages. There are the two sites, side by side, at the widths we verify at.

Before · Webflowscroll for the full page
Full homepage of qed42.com on Webflow at 1440 pixels wide, before the move
After · Drupal 11scroll for the full page
Full homepage of qed42.com replatformed to Drupal 11 at 1440 pixels wide, after the migration

What the pictures cannot show you

Every address the old site advertised has a route on the new one
The full list of addresses the old site publishes is checked against everything the new site can serve, redirects included, and anything left over is a defect rather than a footnote. On qed42.com that list ran to 670 addresses, and the check found 14 category listings missing, which were then built.
Content is traced unit by unit, not sampled
Headings, body copy, link labels and image references are each traced from the reading of the old site through to the rendered page on the new one. Anything that does not arrive is listed by name with a reason, rather than folded into a score.
Checked again after the old site has moved on
A second pass compares the new site against the old one as it stands today, page by page, so anything published, retitled or dropped in the meantime comes back as a worklist for your content team instead of a re-read of the whole site.

Why replatform

The site is not the problem. The platform is.

Most teams that come to us are not unhappy with how their website looks. They are stuck behind what the platform underneath it will let them do: no real content model, no way to add AI features, no route to being cited when someone asks a model a question instead of typing it into a search box. Modernising a website in 2026 comes down to four things: AI inside the CMS, digital sovereignty over the site and its content, an open architecture, and readiness for AI agents. Replatforming to Drupal 11 is the step that gets a site there, and it is the reason this harness exists.

Today, on a page editor

Pages, each one edited on its own.

After, on Drupal

One typed record, read by:

  • A page
  • A listing
  • An API and JSON-LD
A page editor gives you pages. A content model gives you records that a page, a listing and an API can each read.
AI inside the CMS
The Drupal AI module suite is installed on the delivered site, with an AI assistant button in every rich-text editor and a log of every AI call. It runs against your own provider keys, so AI is a feature of your CMS rather than a separate tool to buy.
Digital sovereignty: a CMS you own
The finished site is handed over as a portable package: its configuration, content and theme, a Drupal Recipe, and a database dump that is proven to restore. It installs on any Drupal 11 host you choose, with zero custom modules, so there is no vendor lock-in.
Open architecture, not a page editor
Closed platforms give you pages. Open-source Drupal 11 and Drupal CMS give you content types, typed fields, native listings, roles, and a read-only JSON:API over the content. The move is what turns a website into a system your team can build on.
Ready for AI agents
The delivered site serves an llms.txt map, a markdown twin of every content page, read-only JSON for each content item and a schema.org entity graph, and its robots.txt gives each named AI crawler a rule of its own. The AI ready section below links the live addresses on qed42.com.
Publishing without a developer
Editors compose pages from typed components, manage media, schedule and preview, and publish. The queue of small copy changes that used to need a deployment stops existing.
Search standing carried across
Existing URLs stay as they are, the redirects the old site already had are carried over, and metadata, canonical tags and an XML sitemap for each content type are configured in the move itself. Replatforming is where search rankings are usually lost, so it is treated as delivery work, not cleanup.

How it runs

Five steps, one deliverable

  1. Step 1

    Read

    X to Drupal studies your live site the way an architect would: the design system, the components that repeat, the content underneath them, and the listings that tie it together.

  2. Step 2

    Replatform

    It lands the site on Drupal 11: a theme that reproduces the design, and a content model with typed components, Views and taxonomies a senior Drupal architect would recognise. Your articles and images migrate into it.

  3. Step 3

    Wire it up

    Drupal's AI layer is configured against your own provider keys, and the search foundations go on in the same pass: structured data from the content model, metadata, clean paths, redirects, sitemaps, and the surfaces an LLM reads.

  4. Step 4

    Verify

    The result is checked against your live site, side by side, until the differences are boring. Every width your design declares is checked, not only the three we publish, and the check signs in to cover the admin screens your team will use. We publish the comparison and the honest limits, never a score.

  5. Step 5

    Document

    A phase of its own writes the runbook: the content architecture in plain English, every component shown populated, and where to go to change each part of a page. It hands over as the editorial guide and as the context an assistant reads before it changes anything.

The deliverable is a finished Drupal 11 site, handed over with its configuration, its content and its runbook, installable from scratch as a Recipe.

AI ready on arrival

A site that reads well to people and to models

A growing share of the people looking for what you sell will describe their problem to a model instead of typing keywords into a search box. Being in that answer is a different job from ranking on a results page: the model has to be able to read your site, understand what your organisation is, and have something specific enough to quote. Migrating to Drupal is the moment to fix that, because the content model is being built anyway.

AI inside the CMS your team opens

Drupal's AI layer, configured
The AI module suite is installed and wired to your own provider keys on the delivered site, so the capability belongs to your CMS and your account, not to a tool we keep hold of.
Media descriptions generated
Images arrive in Drupal media with alternative text generated where it was missing, which is an accessibility fix and a search fix in the same pass.
Metadata drafted per content type
Page titles, meta descriptions and social metadata can be generated per bundle from the content itself, with an editor approving rather than authoring from a blank field.
Usage you can account for
The AI layer records which model was called, for which task and when, without recording the content of prompts or responses, and those records go to the site's own log rather than to a third-party service. Provider keys are read from the environment, so they never travel in a configuration export or a database dump.

The site itself, readable by a model

A structured entity graph
Organisation, website, page, article and service structured data is emitted as JSON-LD from the content model rather than pasted per page, so what a machine reads and what a visitor reads cannot drift apart. FAQ and breadcrumb markup can be added as part of a custom scope.
An llms.txt map of the site
The convention that sits beside robots.txt and sitemap.xml: a plain-text summary of what the site is and a list of its canonical URLs, written for assistants rather than for browsers. qed42.com/llms.txt
Clean markdown of every page
A markdown rendering of each page alongside the HTML, so a model ingesting the site gets the prose and the headings without navigation, scripts and styling in the way. qed42.com/insights.md
JSON for every content item
Read-only structured JSON per content item from Drupal's own API layer, so the content is consumable as data by an assistant, an agent or an internal tool without scraping. It is exposed for reading only, and the accounts resource is switched off. qed42.com/jsonapi
Per-bot crawl rules
Named directives for the AI crawlers and LLMs, so the decision about which models may read the site is yours and is stated rather than left to chance. qed42.com/robots.txt

Still in build

Both of these extend something already on the delivered site rather than being the foundation for it, so nothing above is waiting on them. They stay labelled this way until the day they ship, which is the rule the rest of this page follows.

Deeper AI authoringIn build
Long-form expansion, summaries and taxonomy suggestions applied across an existing library rather than a page at a time.
A deeper automated SEO auditIn build
A standing sweep of sitemap coverage, the crawl surface and metadata quality, reported per finding against the rule it broke.

You can check the machine-readable side on both sites rather than taking it on trust. The Drupal site we delivered serves the four surfaces linked above, and this site serves its own llms.txt, a full-text llms-full.txt and a markdown copy of every article.

What you get

A backend a Drupal architect would sign off on

The pixels are what stakeholders look at. What decides whether the move was worth it is what your team can do on the Monday after.

Typed components, not frozen pages
Every page is composed from paragraph components with typed fields. Editors change copy, images and layout from the Drupal admin and publish without a developer or a deployment.
Listings that build themselves
Article indexes, case study grids and filtered archives arrive as real Drupal Views. Publish a new article and every listing that should show it already does.
Your taxonomy, made real
Categories, industries and topics become Drupal taxonomies mapped from the site as it exists today, so filtering and related content work from structure, not string matching.
Editorial plumbing from Drupal CMS
Media management, scheduling and permissions ship configured from Drupal CMS. A large part of the site arrives finished rather than as a backlog.
SEO foundations configured
Page metadata, clean paths, redirects from the old URLs, sitemaps and JSON-LD structured data are set up on the delivered site. Search standing is protected during the move rather than repaired after it.
An editor role that is not the admin login
The delivered site ships a content editor role built from this site's own model: create and edit across every content type and media type, terms, aliases, redirects and scheduling, with menu access limited to the site's own menus rather than a blanket grant.
Accessibility handled during the move
Image fields require alternative text, so an image cannot be saved without it, and the page templates carry the landmarks and the skip-link anchor keyboard and screen reader users rely on. Delivered pages are then swept automatically and every finding is reported with the rule it broke.
Reproducible, and yours
Zero custom modules carry the site. The whole build installs on a fresh Drupal 11 as a Recipe, so any Drupal team can stand it up, audit it and own it.

What arrives configured

The parts behind the pages, already done

A replatform is often planned around the pages, with the rest left as assumptions: the editorial setup, the caching, the image handling, the roles, the headers a security review will ask about. Those are the parts that decide whether the site is pleasant to run. They arrive configured, and they are itemised here so you can check each one.

The editorial experience

The admin your team actually opens, set up around this site's own content model rather than left at Drupal's defaults.

  • A preview button on every component, before anything is saved
  • Scheduled publishing, and bulk publish and unpublish from the content list
  • A media library that arrives already holding the site's own images, not an empty grid
  • Focal-point cropping, and revisions on every content type
  • Deleted pages go to a trash area rather than disappearing
  • Enquiry forms editable in the admin, with submissions kept in the site's own database

AI in the CMS

Configured against your own provider keys, so the capability belongs to your account rather than to a tool we keep hold of.

  • Assistive authoring and content suggestions inside the editor
  • Alternative text generated for images that arrived without it
  • More than one provider installed, so you choose which one answers
  • Model, task and time logged; prompt and response content is not

Performance and delivery

The parts of a Drupal build that decide what a page weighs and how long it takes, configured rather than left to a later phase.

  • Page, dynamic page and render caching on, with an object cache backend wired
  • Images converted to WebP and cropped from a focal point per aspect ratio
  • The image handling is proven able to process your formats before it is relied on
  • Deferred page assembly, so the shell renders before the slow parts finish
  • Cache invalidation wired to content changes rather than to a timer

Security and privacy

In place on the site as handed over, not deferred to a hardening phase after launch.

  • A content security policy that is enforcing rather than report-only
  • Editor tooling served from your own site, so no admin screen depends on an outside network
  • Same-origin framing, a strict referrer policy, and HTTPS-only strict transport security carried over where your current site already sends it
  • A content editor role that is not an administrator role
  • Spam checks that run on the site, so no visitor is sent elsewhere to prove they are human
  • A consent manager, and keys read from the environment rather than stored in the database

Everything above is configuration on the delivered site, which means it installs with the Recipe and can be read, audited and changed by any Drupal team. None of it is a custom module, and none of it depends on us afterwards. An editorial approval workflow, with review before anything is published, can be added as part of a custom scope.

Everything a replatform includes, and what is scoped separately

Beyond the replatform

Your marketing team can run it from the first week

A replatform usually ends the way every replatform ends: a training week, a slide deck, and one or two people who know where everything lives. Closing that gap is part of the delivery here. The site arrives documenting itself for the people who will change it, and it arrives reachable, so a change can be described in plain language and staged in the CMS as a draft by someone who has never opened Drupal before.

  1. One

    A runbook, generated with the site

    A phase of the run produces a guidebook to the site it has just built, written for someone who does not work in Drupal. Every component is shown populated rather than described, so an editor can see what a section looks like before touching it and can find the screen that produces it. It does the job a training week does, and unlike a training week it is still there in six months.

    • Every component previewed as it looks populated, not described in the abstract
    • Where each part of a page comes from, and which component holds it
    • How to manage taxonomies, menus and listings, step by step
    • The same document is the context an assistant reads before it changes anything
  2. Two

    Changes asked for in plain language, staged in the CMS

    The delivered site is wired for a Model Context Protocol connection, an open standard that lets an AI assistant work through an application's own interface instead of around it. Your team asks for a page, a component or a copy change, and it arrives in Drupal as a draft built through that content type's own rules, so the metadata, the path and the structured data are filled the way the content type already defines them. Nothing publishes itself.

    • Content arrives in draft, with the content type's own search fields already filled
    • Drupal's roles, permissions and revisions still apply, because the change goes through them
    • Anyone on the content team can ask, not only the people who sat through the handover
    • Marketing moves without raising a ticket with a development team
  3. Three

    Your brand, handed over as context

    The run captures the design system it has just reproduced: the colours, the type, the spacing, the components and the rules that hold them together, alongside the voice the existing site is written in. That context is delivered with the site, so a change requested a year later is drafted in your brand rather than in a generic one.

    • The design system delivered as context, not only as stylesheets
    • Component rules travel with the components they govern
    • What comes back a year later is still recognisably yours

Together these are the difference between a site that is finished and a site that is genuinely handed over. The runbook says where everything is, the connection lets someone change it in plain language, and the brand context keeps what comes back looking like you.

Where it fits

For sites that are assets, not drafts

AI site builders and managed SaaS platforms are good at starting over. X to Drupal is for the other case: the site you already invested in is the site you want, modernised on a platform you own.

 Replatform with X to DrupalManual replatformNew build on a site builder
Your current designPreserved and verified side by sideRecreated by hand from screenshotsReplaced with a new design
Your contentCarried into a real content modelRe-entered or scripted per projectRe-entered on the new platform
OwnershipOpen-source Drupal 11, exportable to any Drupal 11 hostDepends on the target platformLives on the vendor's platform
Who can maintain itAny Drupal team, zero custom modules to learnWhoever built it, at firstThe vendor and its ecosystem
After handoverA generated runbook, and changes staged in the CMS on requestA training week and a slide deckThe vendor's help centre
Who can change it laterAnyone on the content team, in plain languageWhoever was trained on itAnyone, inside the vendor's editor
AI and LLMsAI layer configured, structured data from the content modelA separate project after the moveWhatever the vendor chooses to expose
Where the time goesThe harness does the transcription workMost of the time is transcriptionA new build, plus the content move

Honest limits

What we say out loud before you ask

Animation is the hard part

Animation-heavy sections are the hardest thing to reproduce exactly. Where the original leans on motion, the migrated site gets closest to the resting state, and we show you those sections in the comparison instead of cropping them out.

No parity percentage, ever

Fidelity varies by page and by viewport, and an average flatters the easy pages. The side-by-side comparison is the claim, and you are free to judge it harshly.

Roadmap, labelled as roadmap

Two items are still in build and say so wherever they appear: deeper AI authoring across an existing library, and a deeper automated SEO audit. Everything else in the AI section is configured on delivery, and the machine-readable surfaces are linked there so you can open them on the site we delivered instead of taking our word for it.

An accessibility sweep is not a conformance statement

Alternative text is enforced on image fields, the page templates carry landmarks and a working skip link, and delivered pages are swept with the standard automated rule set, with every finding reported against the rule it broke. An automated sweep catches a portion of what an audit would. If you need a conformance statement, that is a separate piece of work and we will say so.

Consent blocks what is registered with it

The delivered site ships a consent manager wired to rewrite third-party embeds so they load only after a decision. What it covers is what has been registered with it, which on a given build is a short list rather than everything on the page. It is a working foundation and a launch checklist item, not a finished privacy review.

Editor guidance is partial on the first build

Components arrive with typed fields and a preview button, and search metadata sits where Drupal editors already look for it. Plain-English help text on every individual field is not complete on the reference build; it is written for new fields as they are generated, and finishing it on an existing build is a small, visible piece of work rather than a hidden one.

Scoped against the real thing

The transcription work of a replatform, reading every page and rebuilding it on Drupal, is done by the harness run. The delivery team's hands-on work around it, from scoping to QA and go-live, is planned against your site. Every engagement is scoped against the site's own shape.

The replatform, not the whole project

A replatform covers the harness run and the delivery team's work around it. Integrations, custom functionality, analytics set-up, hosting and similar work are scoped separately. The full list of what sits on each side of the line is on what a replatform includes.

From the series

The whole story, written down

All posts

Questions

The things buyers actually ask

What is X to Drupal?

X to Drupal is a harness built by QED42 that modernises an existing website on any platform by replatforming it onto a real Drupal CMS. The visual result is preserved, your content migrates across, and the backend is modelled the way a senior Drupal architect would model it: typed components, real listings and taxonomies. It is a paid QED42 offering, delivered as a finished Drupal 11 site that you own and can install on any Drupal 11 host.

Is X to Drupal a migration or a modernisation?

A modernisation, and the migration is one step of it. Modernising a website in 2026 means four things: AI inside the CMS, digital sovereignty, an open architecture, and readiness for AI agents. X to Drupal replatforms the site to Drupal 11 and Drupal CMS with the design kept and the content moved into a real content model, and that move is what gets the site to all four. The delivered site ships the Drupal AI module suite with an AI assistant button in the editor, an llms.txt map, a markdown twin of every content page, a read-only JSON:API and robots.txt rules for each named AI crawler. It is handed over as a Drupal Recipe and a database dump that is proven to restore, so it installs on any Drupal 11 host with no vendor lock-in.

What does replatforming a website to Drupal actually give us?

A platform instead of a page editor. You get content types and fields, revisions, roles and permissions, media management, and an API over all of it, so your team can publish and extend the site without a developer or a deployment. On top of that the delivered site arrives with Drupal's AI layer configured, structured data emitted from the content model, search foundations carried across, and open-source hosting you choose. The reason most teams replatform is not how the site looks, it is what the current platform will not let them do next.

Will our site look the same after we replatform?

That is the point of the harness. The design comes across as it is, and we verify the result side by side against your live site at 1440, 768 and 375 pixels wide. We publish the comparison rather than a parity score, because a single number flatters the easy pages. The before and after of our own site is on this page.

What happens to our existing articles and images?

They migrate into a real Drupal content model. On our own site that meant 569 article bodies moved across with their formatting intact and 2,007 images brought into Drupal's own media handling. Listings become Drupal Views, categories become taxonomies, and every article becomes a structured node your team can edit.

Will our website be visible to LLMs after the migration?

That is treated as delivery work rather than a later project. The delivered site emits a structured JSON-LD entity graph from the content model, so an assistant reading your pages can tell what your organisation is, what each page is about and how they relate, instead of guessing from markup. It also arrives with the four machine-readable surfaces configured: an llms.txt map of the site, a markdown rendering of every page, read-only JSON for every content item, and named crawl rules for the LLMs. Metadata, clean paths, redirects from your old URLs and sitemaps are configured in the same pass. You do not have to take this on trust: qed42.com is the Drupal site we delivered, and it serves qed42.com/llms.txt, a markdown twin of every page, qed42.com/jsonapi and a robots.txt that names the AI crawlers one by one.

How do you make a website readable by LLMs and AI assistants?

By publishing the same content in formats a machine can consume without scraping. Three things do most of the work: structured data in JSON-LD so entities and relationships are explicit, a plain-text map at llms.txt that tells an assistant what the site is and lists its canonical URLs, and a clean markdown or JSON copy of each page so the prose arrives without navigation, scripts and styling wrapped around it. Migrating to Drupal is the moment to put these in, because the content model that generates them is being built anyway. On a closed platform you usually cannot add them at all.

What AI features does the delivered Drupal site come with?

Drupal's AI module suite is installed and wired to your own model provider keys, so the capability belongs to your CMS and your account rather than to a tool we hold. On delivery that covers assistive authoring inside the editorial experience, alternative text generated for images that were missing it, and page titles, meta descriptions and social metadata drafted per content type from the content itself, with an editor approving rather than starting from a blank field. Two things are still in build and we label them that way: deeper AI authoring across an existing library, such as long-form expansion and summaries applied in bulk, and a deeper automated SEO audit.

How do we train our content team on the new Drupal site?

You get a runbook instead of a training course. A phase of the run generates a guidebook to the site it has just built, written for someone who does not work in Drupal: the content architecture in plain English, every component shown as it looks once it is populated, where each part of a page comes from and which component holds it, and how to manage taxonomies, menus and listings. It is handed over with the site, so the knowledge does not sit with the one or two people who happened to attend a session, and it is still there six months later when someone new joins.

Can our marketing team change the site without a developer after we migrate?

Yes, and in plain language. The delivered site is wired for a Model Context Protocol connection, an open standard that lets an AI assistant work through an application's own interface rather than around it. Someone on the content team asks for a page, a component or a copy change, and it arrives in Drupal as a draft built through that content type's own rules, so the metadata, the path and the structured data are filled the way the content type already defines them. Nothing publishes itself: the draft stays unpublished, under the site's own roles, until an editor reviews and publishes it.

Will content drafted by AI still look and sound like our brand?

That is what the brand context is for. The run captures the design system it has just reproduced, the colours, the type, the spacing, the components and the rules that hold them together, alongside the voice the existing site is written in, and hands that over with the site. A change requested a year later is drafted against your own system rather than a generic one, and because it arrives as a draft inside Drupal an editor still sees it before anyone else does.

How long does a replatform with X to Drupal take?

The harness run itself takes days, and it grows with the size of the site: more pages, page templates and forms make a longer run. Most of the calendar time belongs to people: your team's decisions on what to keep and what to retire, the review of the delivered site on your own pages, and the go-live window, with environments, DNS cutover and a rollback plan. The acceleration section on this page shows four typical site shapes, from a small brochure site to a publisher, each with the length of its harness run and the weeks from kickoff to go-live. For your own site, get in touch through the form on this page and we will come back with what replatforming would mean for yours.

Why is replatforming usually quoted as a full rebuild?

Because on a new platform both the design and the content model have to be recreated by hand, page by page and field by field. The old site works as a reference, and everything else is labour. X to Drupal moves that recreation into the harness run, so the design and the content model come across from the site itself, and the first post in our blog series walks through it in detail.

Do we keep our SEO when we replatform?

Search standing is treated as part of the migration. Page metadata, clean paths, redirects from the old URLs, sitemaps and JSON-LD structured data arrive configured on the delivered site rather than left as a to-do list, which is where most replatforming projects lose rankings. The machine-readable surfaces an LLM reads arrive with them, so the site is legible to an assistant on day one rather than after a follow-up project. A deeper automated SEO audit is still in build and we say so plainly rather than counting it as shipped.

How is X to Drupal different from an AI website builder or a managed SaaS CMS?

Those tools help you build a new site on their platform. X to Drupal migrates the site you already have onto Drupal, an open-source CMS you own and can host anywhere, with the design you already invested in preserved. If your website is an asset rather than a draft, keeping it intact is the difference that matters.

Who owns the site afterwards, and is there lock-in?

You own it. The deliverable is a standard Drupal 11 site: typed paragraph components, Views, taxonomies and configuration, with zero custom modules carrying the site. It installs on a fresh Drupal 11 as a Recipe, and any competent Drupal team can maintain it, including one that is not us.

What does X to Drupal not do well?

Animation-heavy sections are the hardest thing to reproduce exactly, and we show them honestly in the side-by-side rather than hiding them. We also never quote a single parity percentage, because fidelity varies by page and viewport. On the AI side, the layer, the structured data and the machine-readable surfaces are all configured on delivery, while deeper AI authoring across a library and a deeper automated SEO audit are in build rather than shipped, and this page names which is which.

Has X to Drupal run on a real production site?

Yes, ours. qed42.com ran on Webflow and was migrated to a Drupal 11 site with X to Drupal: 569 article bodies, 2,007 images, real listings with filters, case studies and forms. That Drupal site is what qed42.com serves today, so the production site and the proof are the same address. Betting our own homepage on it was the fastest way to find out whether the claim survives contact with reality.

Find out what replatforming means for your website

Tell us the site you are living with. We will look at it the way the harness does and come back with what a move to Drupal would actually involve, on your pages, at real widths.

Leave your work address and we will come back with what a move to Drupal would involve on your site. Work email, no drip sequence, unsubscribe from any message.

Or reach QED42 directly