Umbra Roasters
A premium coffee-roastery brand on the Content SDK — and the first full agentic pipeline run taken end-to-end, from cloud provisioning to authored content, without leaving the IDE.
What it is
Umbra Roasters is a premium coffee-roastery brand site, built on the Sitecore Content SDK against a live SitecoreAI tenant. No commerce, no checkout — a marketing site: the roastery story, the bean origins, the process, the people. On its own it is a clean head app. What makes it worth a case study is how it got built.
It was the first full run of the agentic pipeline taken start to finish without a human leaving the editor. Not "the AI wrote the components." The agents stood up the cloud topology, built the head app against real datasource contracts, created a brand-new component end-to-end — React, Sitecore templates, rendering, and content — and wrote the on-brand copy into the tenant. The operator's job was the gates, not the typing.
end-to-end in the IDE
built React-to-content
(DevOps · Content Author)
into the framework
How it actually works
When the pipeline's platform_target is content-sdk, it branches into
a Sitecore-aware flow. The generic stages stay — architect, task
breakdown, implement, review, test, ship — but three Sitecore-specific
stages slot in, and two new agents own them.
The decoupled topology matters. The CM environment is the authoring brain; the head app is a separate editing host that prerenders against Experience Edge. The ordering is load-bearing — the site has to exist and publish before the editing host builds, or the host SSGs against an empty tenant and 404s. That sequencing is exactly the kind of thing the DevOps Engineer agent now encodes so a human never has to remember it.
The component built end-to-end
Most of the build was a faithful port — existing renderings rebuilt in React, bound to their real field contracts. One component was net-new, and it is the proof that the loop closes:
The honest part
Umbra shipped with caveats, and that label is doing real work — it is not a euphemism for "done." The hydration smoke passed across every route in both themes, the Roast Journey rendered end-to-end, and the dual-theme contrast cleared WCAG AA at runtime. What is still open is a short list of operator-driven gates: the full Pages-canvas walkthrough, the motion-on visual pass across all routes, and the deployed-host publish with both Edge contexts pointed at LIVE. They are the kind of checks a person has to eyeball, and they stay with the operator by design.
The more interesting outcome is what the run produced for the framework. Because this was the first time the complete Sitecore website pipeline ran end-to-end, it surfaced exactly where the path was rough — and every rough edge became a permanent improvement:
existing-CM content-model read
+ the DevOps Engineer agent
+ Content Author + Content QA
architect reads the model
That is the dogfood loop doing its job. A skill or a stage is not trusted until something real has been built against it; Umbra was the real thing, and it paid the framework back in guardrails. The next Sitecore site inherits all six.
What it proves
The IDE is the whole workshop.
One run took a site from idea to a built, authored Sitecore site — provisioning the cloud, writing the code, and creating the content — without a human leaving the editor. The boundaries the operator owns are the gates, not the labor.
The AI operates Sitecore, not just codes it.
Beyond the head app, the agents drove Sitecore itself — provisioning environments and authoring content through the Marketer MCP and the official APIs — the way a human team would.
A component can be created top to bottom.
Roast Journey existed as nothing and ended as a first-class, authorable Sitecore rendering with real content rendering live — React, templates, registration, datasource, and copy, all created in one pass.
No mock infrastructure.
The port happened against a LIVE tenant from the first component, so the shapes were real from day one. Mock is an explicit opt-in, never the silent default.
Honesty is a feature.
It shipped as shipped_with_caveats with the open gates named, not buried. The pipeline reports what it actually verified, and a stale-green never gets to pose as done.
Every first run pays rent.
The newest capability re-enters the dogfood loop. Umbra's six fold-backs are the difference between "it worked once" and "the next one is easier" — the compounding the whole framework is built on.
Where it goes next
Two threads. The first is closing Umbra's own gates — the operator walkthrough and the deployed-host publish with both Edge contexts on LIVE — so the site graduates from shipped_with_caveats to plainly shipped.
The second is the bigger bet this run moves toward: generating a head app and its entire content model end-to-end. Umbra proved the loop closes for a single net-new component, including its Sitecore items and content. The next step is to do that for a whole site in one run — templates, renderings, and content created from nothing — until the official Developer MCP makes the provisioning half a first-class primitive. Either way, it ships through the same pipeline that built Umbra, and it starts the same way: a real-tenant probe before the deep planning.
Related case studies
