Conversational gathering
A 5-mode chat flow — gather → design questionnaire → preview → docs → build — captures both structural requirements and the user intent that shapes the final site.
DDEV · Drupal · Recipes · Configs
Build Drupal sites with AI.
In minutes, not days.
A real Drupal codebase on a local DDEV stack. Content types, subtheme, and sample content wired in. Ready for the work only you can do.
~10 min
brief to running site
9
pipeline steps
Recipes
atomic config
Open
template downloads
Core capabilities
Everything you need to ship a Drupal site fast
From conversational requirements gathering to a fully provisioned environment with a custom subtheme, content types, and sample content — no Drupal expertise required.
HTML-first design preview
Approve a real HTML mockup before any Drupal work begins. Iterate on colors, typography, layout, and copy until it matches your vision.
PageBlueprint extraction
Python parses nav, footer, sections, and card patterns from the approved HTML — deterministic data flows into every build doc instead of being re-interpreted by an LLM.
9-step build-doc pipeline
DDEV provision → contrib modules → 4-stage Bootstrap Barrio subtheme → configuration → sample content → verification. Each step runs deterministically from a structured markdown doc.
Drupal Recipes (atomic config)
Content types, fields, taxonomies, views, and block types apply atomically via drush recipe with full Drupal schema validation — no silent failures.
Rollback + resume
Every change is tracked. On failure, only the failing step rolls back — completed steps survive. A .build-progress.json manifest lets you resume right where you left off.
Conversation mode
Chat → site, automatically
The gathering mode collects structured requirements and preserves user intent. Once complete, a [DESIGN_READY] marker unlocks the design questionnaire and HTML preview.
Reply with adjustments, or continue to design…
Continue →
Execution pipeline
9-step agent orchestration
The OrchestratorAgent reads build-docs/MASTER.md and delegates each step to a specialized agent. A baseline subtheme is applied first so the site is always usable — later steps degrade gracefully via per-step rollback.
01
DDEV Provision
ddev config + start + composer create-project + drush site:install (Standard profile)
02
Contrib Modules
composer require + drush en — pathauto, metatag, simple_sitemap, twig_tweak, redirect
03a
Subtheme Config
Barrio subtheme .info.yml + .libraries.yml with blueprint-derived regions
03b
Subtheme CSS
style.css generated from the approved HTML preview's
<style> block03c
Subtheme Templates
page--front, page, node teasers, views wrappers — 4 parallel LLM calls
03d
Subtheme JS + Activate
behaviors.js + drush theme:enable + set as default
04–07
Configuration (Recipe)
drush recipe — content types, fields, taxonomies, views, pathauto, metatag, sitemap
08
Sample Content
drush php:eval — sample nodes, taxonomy terms, main + footer menu links
09
Verify
Smoke tests, route validation, and the preview URL returned to the frontend
How it compares
drupod vs. building a Drupal site by hand
Manual Drupal still wins on edge cases and total control. drupod wins on speed, baseline quality, and avoiding the parts you'd rather not do twice.
| drupod (LLM pipeline) | Manual Drupal build | |
|---|---|---|
| Time to working preview | ~10 minutes from brief to running DDEV site | 1–3 days for an experienced Drupal dev to scaffold an equivalent baseline |
| Drupal expertise required | ✓ None — a guided interview gathers requirements | Drupal, DDEV, Composer, Drush, YAML config, Twig fundamentals |
| Config quality | YAML assembled from a production-exported template library + Drupal Recipes (schema validation) | However careful you are — usually fine if you've shipped Drupal before |
| Custom design fidelity | HTML preview approved before any Drupal work — PageBlueprint pulls nav, footer, sections, card classes deterministically | Pixel-perfect — you control every Twig file and CSS class yourself |
| When something breaks | Per-step rollback + a .build-progress.json manifest lets you resume mid-pipeline |
You debug it. Could be 5 minutes, could be 3 hours. |
| Edge cases & bespoke modules | Pipeline focuses on common shapes (blog, portfolio, event site, business, landing) — anything truly bespoke still needs a human | ✓ Total freedom — write the module, write the migration, ship it |
| Cost | Low-cost tiered pricing at launch. Starting template library is a free download. | Your time (or a contractor's billable hour) |
Drupod isn't trying to replace a senior Drupal dev. It's trying to replace the first 80% of the work — the scaffolding, the YAML, the subtheme boilerplate — so the human can focus on the 20% that's actually interesting.
Mockup — coming when we launch
Environment management
Preview: the sites dashboard
This is how managing builds will look when drupod ships. Spin up sites, watch them provision, hand off previews — all from one place.
Things you're probably wondering
Straight answers
The questions developers actually ask
Isn't this just another GPT wrapper?
Most of the pipeline is deterministic Python. The LLM is scoped to three slots: a chat front-end for requirements, JSON output specifying which fields go on each content type, and the CSS + Twig generated from your approved HTML preview. Everything else like YAML config, block placement, menu links, sample content, DDEV provisioning is plain Python pulling templates from a working production Drupal site.
Why Drupal in 2026? Isn't it kinda over?
Drupal didn't die, it just stopped being loud. There are still tens of thousands of agencies and in-house teams shipping Drupal sites every week like government, higher-ed, nonprofits, publishing, anyone whose lawyers care about the CMS being on-prem. The pain point isn't "is Drupal good?" it's "Drupal is heavy to setup from scratch."
What happens when a step in the pipeline fails halfway?
Each of the 9 build steps is wrapped in a RollbackTracker checkpoint. If step 7 (config recipe) fails, only step 7's changes roll back — steps 1–6 stay applied. A build-progress.json manifest records what's done, so you can fix the underlying problem (usually a YAML validation issue) and resume from the failed step instead of starting over.
The config validator catches the common YAML mistakes (missing field_type, flat-map allowed_values, blank help text) and auto-fixes the ones it knows. Anything it can't fix gets skipped with a clear log line, never silently imported.
Will the generated Drupal code be maintainable, or is this AI slop I'll regret?
The YAML config is assembled from a working Drupal site's config export, then applied via drush recipe (Drupal's atomic config installer). The Twig and CSS come from the LLM. They use idiomatic Drupal helpers drupal_view(), {{ content|without(...) }} not React-flavored gibberish. If you'll spend years on the site, treat the output as a starting point you'll refactor. Same as a junior dev's first PR.
When can I actually use this? And what's not working yet?
Pre-launch as of 2026. The full pipeline runs end-to-end on common shapes (blog, portfolio, business, landing, event site). Sign up above and you'll get a heads-up the moment private beta opens.
Not done yet: Drupal Commerce flows, multi-site setups, complex migrations from existing CMS exports, custom module generation. Those are on the roadmap but won't ship in v1. If your site needs any of those, drupod will get you 80% there and then it's manual work.
What will it cost?
Pricing will be tiers for pay per build or a small monthly bucket. Final numbers aren't locked yet.
The starting template library is free, though: production-derived content types, taxonomies, views, and subtheme scaffolds you can download directly, import into drupod to remix, or use straight in your own Drupal install. Same shape as the existing free Drupal contrib template libraries.
If you're an agency on the early access list and want to talk pricing before launch, reach out via email.