# Roboto Studio - Complete Content
> This file contains all content from robotostudio.com in markdown format.
> Optimized for LLM consumption and RAG systems.
---
# Services
## Agentic websites
> We build fast, type-safe websites engineered for SEO, AEO and conversion. Your AI agent ships landing pages on the rails. Bring v0, Lovable, Cursor, Replit or Codex.
**Updated:** 2026-07-05
---
Companies of all sizes trust Roboto Studio
An agentic website is one your marketing team builds on with its own AI coding agent. We hand over a fast, type-safe foundation, and your content lives as structured files in your own repository. You point the agent your team already builds with at those files (v0, Lovable, Replit, Cursor, Codex, Claude Code), describe the landing page or campaign you need, and it assembles the page from components we have already tuned for speed and conversion. Today a campaign page often means a brief, a developer queue and a sprint of waiting, so it can go live after the moment that prompted it has passed. With an agentic website you brief your agent and preview the page the same day.
Coding agents only recently got good enough to build whole pages from a prompt. Raw agent output tends to drift off-brand, load slowly and ship thin, half-crawlable HTML. The foundation prevents that. It is the rails: typed components, your design system and validation that keep whatever the agent produces fast, crawlable and on-brand before it reaches a visitor.
We don't sell you our agent. We build the website yours can safely work in, and that website speaks the plain, structured language every current and future coding agent already reads, with no onboarding call and no proprietary format to learn. When a faster model or a better tool arrives next quarter, you switch to it and nothing about your site has to change, because the rails live in the foundation rather than the agent itself.
Hand an unguarded AI tool your homepage and it will happily produce an off-brand, slow, half-crawlable page. We remove that risk at the source. Every page your agent builds is assembled from typed, conversion-tested components and validated against a Zod schema before it can ship. A missing meta description, a broken image path, an invalid layout: each one fails the build instead of reaching your visitors.
So your agent moves fast and the guardrails hold. Marketers describe what they want, the agent assembles approved blocks, and the rails make sure the output stays on-brand, fast and ready to rank.
Your pages are plain files in your own repository, so you own every word outright. A headless CMS bills you per editor seat and meters your API, so the cost of shipping climbs with every marketer you hire and every page you serve. Here it stays flat: add ten marketers or a hundred, and there is no rate limit on launch day and no vendor sitting between you and your own back catalogue.
Every change is versioned, so when a headline edit moves the numbers the wrong way, you can see exactly what changed, who changed it and when, then restore the winning page in seconds. Your campaign copy gets the audit trail your spend reports already have, and nothing you publish is locked inside a tool you would have to buy your way out of.
A prompt can produce a page in minutes, which is why an agentic website can look, at a glance, like one more AI page builder. The difference is what survives once you are shipping dozens of pages a month: whether each one stays fast, findable and on-brand, or whether the quality quietly slides as the count climbs. Holding that line is the work the foundation does. Components are checked before a page can preview, so what reaches your visitors looks reviewed even when an agent wrote it in a single pass. That is the difference between a quick draft and a page you can put ad budget behind.
| Approach | What ships |
| --- | --- |
| An AI builder with no guardrails | A quick first draft that drifts off-brand, with thin HTML and performance that slips as pages pile up |
| A traditional CMS | A polished editor, plus a dev ticket and a sprint wait for anything the template does not already do |
| An agentic website | Your agent on our rails: every page crawlable, fast, on-brand and conversion-ready the moment it ships |
My best experience with a consulting company. The results were delivered faster than expected and with top quality. Jono ensured I understood the process and suggested a great approach. Both execution and communication were flawless.
Agentic builds we've shipped
## Vercel agency partner
A Vercel partner agency, building fast, type-safe websites on Next.js and the Vercel stack that your AI agent can build on from day one.
## Thinking about an agentic website?
Here are the questions we hear most often
### Which AI agents can I use?
Whichever your team already works in. We have handed sites to teams using v0, Lovable, Cursor, Replit, Codex and Claude Code. The website is plain structured files, so any current or future coding agent can read and edit it. You are never tied to one vendor's tool.
### What stops the agent from making a mess?
The rails. Every page is built from typed components and checked against a Zod schema before it ships, so broken metadata, missing images or invalid layouts fail the build rather than reaching your visitors. Each change also lands as a preview you approve before it goes live. The agent moves fast inside boundaries you control.
### Is this what people mean by vibe marketing?
It is the part that makes vibe marketing safe to ship. Prompting a page into existence is easy. Making sure that page is fast, on-brand and built to convert is the hard part, and that is what the foundation handles. You get the speed of describing a page in plain English with the quality bar of an agency build.
### Is this the same as your agentic workflows service?
No, they pair well but solve different problems. An agentic website gives your team's coding agent a safe foundation to build pages on. Our [agentic workflows service](/services/agentic-workflows) is where we build the agents: content pipelines, lead enrichment, background agents that monitor and act. Plenty of clients start with one and add the other once the first system proves itself.
### What is an agentic CMS?
It is a content setup where an AI agent is a first-class editor, not an afterthought. Instead of a proprietary dashboard, your content lives as structured files an agent can read, write and validate. You still get previews, version history and review, with an agent doing the heavy lifting and your team approving the result.
### How does this help SEO and AI search?
Two ways. Pages render as fast, fully crawlable HTML with structured data, which is what both Google and answer engines like ChatGPT and Perplexity need to read and cite you. And because new pages are cheap to produce, you can cover the long-tail and programmatic queries that a hand-built site never reaches.
### Do my marketers need to write code?
No. They describe the page they want and the agent builds it, the same way they already brief a designer. The rails handle the technical correctness underneath. For teams that prefer a visual flow, we set up preview links so every change can be seen before it goes live.
### Can we move our existing site onto this?
Yes. We migrate your current pages into the new foundation, map redirects so your rankings carry over, and hand you a site your marketing team and its agent can build on. Moving off an aging WordPress or legacy CMS does not mean a publishing freeze.
## Bring your agent. We will build the rails.
Tell us the tool your team builds with and the pages you need to ship. We will scope the foundation that keeps everything it makes fast, found and on-brand.
From the blog
---
## AI automation services
> Custom AI automation: production AI agents and agentic workflows on Vercel, built and maintained by the engineers who ship them.
**Updated:** 2026-07-09
---
## The AI automation you prototyped, rebuilt to run in production
You've already prototyped the AI feature. We rebuild it to run in production: durable workflows on Vercel that survive deployments, retry failed steps, and keep running under real traffic. The same pattern that briefs our sales team within a minute of a form submit, fills a content calendar overnight, and keeps a product catalogue current without anyone opening a spreadsheet.
Companies of all sizes trust Roboto Studio
My best experience with a consulting company. The results were delivered faster than expected and with top quality. Jono ensured I understood the process and suggested a great approach. Both execution and communication were flawless.
Production builds we've shipped
## How these work in practice
Every workflow below runs in production. They survive server restarts, retry failed steps automatically, and pause for external events without consuming compute. Here's what that looks like for real problems.
Your marketing team knows they should publish more. They don't have the hours. Here's what we build: a workflow that connects to the Ahrefs API, pulls your keyword gaps and ranking opportunities, then generates research briefs for each topic. A second workflow takes those briefs, researches the subject using AI, writes a first draft, and pushes it to your CMS as a draft post.
Set the whole thing on a CRON schedule. Monday morning, your editor opens Sanity and finds five draft posts waiting for review, each targeted at a keyword your competitors rank for and you don't. The AI did the research and the first draft. Your writer does the thinking and the polish.
Each step in the pipeline retries independently. If the Ahrefs API rate-limits you, that step waits and retries. If the LLM call fails, it tries again without re-fetching the keyword data. Deploy a code update while a draft is mid-generation? The workflow finishes on the old version.
If you operate in multiple markets, the same pipeline can generate localised versions of each post. The workflow takes your approved English draft, translates it, adjusts examples and references for the target region, and pushes each version to the correct locale in your CMS. One editorial review produces content for every market you sell into.
When someone submits a contact form on our site, a workflow kicks off within seconds. It extracts the domain from their email, scrapes their company's website for context, then sends everything to Claude. The AI researches the company, looks at what they do, checks for recent news or funding rounds, and generates a structured brief. That brief lands in our Slack within a minute of the form submission.
The entire thing is about 40 lines of TypeScript. Each step uses a `"use step"` directive, so if Claude's API is slow or Slack returns a 500, that individual step retries without re-scraping the website. We use this ourselves, every day.
For clients, we extend this pattern to push enrichment data into their CRM, score leads based on company fit, and trigger different follow-up sequences depending on what the AI finds. A SaaS company can automatically route enterprise leads to their sales team and self-serve leads to a product tour.
Workflows are great for request-response pipelines. Some problems need an agent that lives in the background, watches for changes, decides what to do, and acts. Stale comparison pages that need fact-checking against a competitor's docs. Brand citation alerts in ChatGPT and Perplexity. A llms.txt file that should regenerate every time the product changes.
We build these on eve, Vercel's open-source agent framework. eve treats an agent as ordinary files in a TypeScript repo: a markdown system prompt, typed tool definitions, and `defineSchedule` for the cron that wakes it up. Sessions are durable by default, built on the same workflow engine as our pipelines, so an agent halfway through a task survives a crash or a deploy. When it needs to run code, it does so inside an isolated Vercel Sandbox, never against your production environment. The same agent runs locally under `eve dev` and on Vercel in production. Schedules trigger them. Remote webhooks trigger them. Other agents trigger them.
Credentials stay out of the codebase. When an agent posts to Slack, opens a pull request, or writes to your CRM, it asks Vercel Connect for a short-lived, scoped token at runtime instead of reading a long-lived secret from an environment variable. The keys stay centralised and auditable, and you revoke access at the provider rather than by redeploying.
Roboto's own CMS migration pages are kept current by a weekly background agent that scrapes the source CMS's docs, diffs against our YAML, and opens a pull request when something is out of date. The agent we built for ourselves is the same agent we ship to clients. If you want one watching your competitor's pricing, your product changelog, your brand citations across the AI search surfaces, we build it on the same foundation.
An agent without evals is a demo. The moment you connect it to real data, a prompt change can break it silently. We build eval pipelines alongside every production agent: golden datasets of inputs your agent should handle, deterministic checks for the parts you can grade with code, and LLM-as-judge grading for the parts you can't.
Every prompt change runs through the eval suite before it ships. Every model upgrade gets scored before you switch over. Regressions get caught before your editor reviews a bad draft or your sales team gets a wrong brief. The eval suite is the closest thing agentic systems have to a test suite.
We treat evals as a productised add-on. They can be the starting point of an engagement if you already have an agent in production that isn't trustworthy, or they can be built alongside a new agent from day one.
The stack behind these systems
Vercel's open-source agent framework, and what our background agents actually run on. An agent is a directory of files in your repo, so it ships through the same branches, pull requests, and preview deploys as the rest of your code. Durable sessions, sandboxing, human approvals, and evals all come built in.
The Workflow Development Kit gives every step automatic retries, durable state, and replay-on-deploy. Open source, runs anywhere, but pairs cleanly with Vercel Fluid Compute.
Provider-agnostic model calls, structured outputs via Zod, tool use, streaming, and observability. Switch models without rewriting the agent.
Isolated microVMs for code execution inside an agent. Lets agents run shell commands, clone repos, and execute generated code without giving them production access.
Short-lived, scoped credentials for agents. Rather than long-lived secrets sitting in environment variables, an agent requests a token at runtime to act in Slack, GitHub, Salesforce, or any OAuth or API-key service. Access stays scoped per project and revocable at the provider.
Every model call, every tool invocation, every conversation captured for review. Quality regressions and cost blowouts get caught the day they happen, not the week after.
## Forward deployed engineers, embedded in your team
Agentic systems live inside your codebase, your content models, and your observability stack. They need daily iteration on prompts, tools, and editorial review.
So we ship them the way Palantir, OpenAI, and Anthropic ship AI: by embedding senior engineers directly into your team for the life of the engagement.
A Roboto FDE engagement puts one or two senior engineers into your codebase with the same access as your own team. Shared Slack channel, repo write access, on-call posture for the agents we ship. Weekly demos, daily-or-better async updates, and a documented playbook your team owns when the engagement winds down. We transfer knowledge as we go, so nothing depends on a rushed handover at the end.
The cadence matters because agentic systems aren't ship-and-walk-away projects. Prompt iteration runs daily once the agent hits real traffic. Tool integrations break in ways nobody predicts at scoping. Editorial review needs context only your team can give. An external vendor on a weekly call is too slow for that loop.
Engagements run a minimum of eight to twelve weeks so the build, observe, and iterate cycle has room to play out. Most settle into a rolling monthly retainer once the first systems are live and the next ones are queued.
CMS migrations, headless Shopify builds, and Contentful implementations all ship cleanly as projects with handoff boundaries. Agentic work doesn't. The output is your voice, your data, and your customer-facing automation, and it changes weekly based on what real usage reveals.
That's why FDE applies to agentic workflows and AEO engagements, not to every service Roboto offers. If you're after a fixed-scope build with a clean handoff, our project teams handle that. If you're after an agent or workflow that needs to keep getting better in production, you want the embedded model.
## Vercel agency partner
A Vercel partner agency, shipping production agents and workflows on Vercel's AI infrastructure since the first release of the Workflow Development Kit.
## Thinking about agentic workflows?
Here are the questions we hear most often
### What does a Forward deployed engineer engagement actually look like?
One or two senior Roboto engineers join your Slack, your repo, and your standups for the life of the engagement. We treat your codebase like ours: branches, pull requests, code review, deploys. Weekly demos cover what shipped, what's queued, and what decisions need your input. Daily async updates keep you ahead of the work. Minimum engagement is eight to twelve weeks; most settle into a rolling monthly retainer once the first agents are live.
### How is this different from a typical AI automation agency?
Most AI automation agencies sell no-code workflows on Zapier, Make, or n8n. Useful for prototypes, fragile in production. We ship typed TypeScript on Vercel's durable workflow runtime, with eval pipelines, observability, and version control. The systems we build live inside your codebase, get reviewed in your pull request flow, and survive your deploys. Different toolchain, different reliability bar.
### What is eve?
eve is Vercel's open-source agent framework, and it's what our production agents run on. It treats an agent as a directory of files in a TypeScript repo: a markdown system prompt, typed tools, schedules, and skills. The framework handles the parts every serious agent needs anyway, like durable sessions that survive a deploy, sandboxed code execution, human-in-the-loop approvals, OpenTelemetry tracing, and an eval harness. Because an agent is just code in your repo, it gets versioned, reviewed, and deployed like everything else you ship. We run our own background agents on eve, so the patterns we bring to your build are ones we've already debugged on ourselves.
### What is a durable workflow?
A program that saves its progress as it runs. If the server crashes, it picks up from the last completed step instead of starting over. Traditional server code loses everything on restart. Durable workflows don't. Think of it like a save point in a game. That makes them the most stable way to run AI systems or anything that needs to wait, for an API response, a human approval, or a scheduled delay, and still finish reliably. For AI orchestration specifically, where you're chaining multiple model calls, tool lookups, and external APIs together, durability turns a fragile chain into one that finishes even when a step fails.
### Do we have to use Vercel?
No. eve and the Workflow Development Kit are both open source, and the AI SDK is portable across model providers, so the core runs on AWS, Google Cloud, or your own servers. Vercel gives you zero-config deployment, managed Sandbox for code execution, and Connect for runtime credentials, which is why we default to it. The architecture travels; the managed convenience is what you'd trade away by self-hosting.
### Can you connect to our existing tools?
If it has an API, we can wire it in. We've built integrations with Ahrefs, PostHog, Slack, Sanity, various CRMs, payment processors, and custom internal tools. Each integration is a step in a workflow, so it gets automatic retries and error handling for free.
### What does 'agentic' mean here?
Software that acts on its own with human oversight. An agentic workflow might research a lead, draft a blog post, or classify a support ticket without anyone clicking a button. A human reviews the output before it goes live. The agent handles the grunt work, people handle the judgment.
### How do you handle AI accuracy?
Every workflow we build has a human review step where it matters. AI drafts the blog post, your editor approves it. AI enriches the lead, your sales rep reads the brief. AI classifies the ticket, your support team sees the suggestion. We don't ship workflows where AI output goes straight to your customers without a check. We also build eval pipelines for every agent we put into production, so quality degradation gets caught before your team feels it.
### We already have AI features. Can you improve what we have?
Most teams we work with have a working prototype that needs to become production-grade. That usually means adding durability so it doesn't break on deploy, observability so you can debug failures, evals so quality stays measurable, and proper error handling so one bad API response doesn't tank the pipeline. We audit what you have and figure out the fastest path to reliable.
## Put an agent to work on your busywork
The content backlog, the unenriched leads, the catalogue nobody can keep current. Pick the one costing your team the most and we'll scope it.
From the blog
---
## CMS migration agency
> CMS migration agency for teams replatforming off WordPress, Webflow, HubSpot, Drupal, Sitecore or Framer. We move content, preserve URLs, and keep search rankings intact so you don't lose 30% of your traffic the week after launch.
**Updated:** 2026-07-05
---
## Move CMS without losing your traffic
#### We replatform WordPress, Webflow, HubSpot CMS, Drupal, Sitecore and Framer sites onto Sanity or Contentful. URLs preserved. JSON-LD parity. Redirect map signed off before cutover. Editors trained before, not after.
The week after launch is where most migrations get judged, and most agencies have already invoiced and moved on. We stay through the post-launch monitoring window, watch the GSC and Ahrefs numbers daily, and fix the things that always surface once Googlebot starts re-crawling.
Migrations we've shipped for
## The SEO migration agency that closes the loop
#### We've moved hundreds of thousands of pages between CMS platforms over the last six years. Every migration has the same risk profile: get the redirects, sitemaps and structured data wrong and you watch months of compounding organic traffic disappear inside a fortnight.
Our process is built around the parts that quietly cost teams their rankings: the redirect map that gets signed off in a spreadsheet before any code ships, the JSON-LD parity audit that confirms every schema type on the old site exists on the new one, the staged cutover that lets us roll back without anyone outside the team noticing, and the 30-day post-launch monitoring window where we catch the regressions Google surfaces a fortnight in.
#### We've been pulled in to recover migrations where the new site shipped clean, looked great, and lost 30 to 70% of organic traffic in the first month. The pattern is always one of four root causes.
**Broken redirect maps.** The team mapped the top 100 URLs, missed the 4,000 long-tail pages with three backlinks each, and surrendered all of that link equity to a soft 404.
**JSON-LD that quietly went missing.** The old WordPress site had Article, FAQPage, BreadcrumbList and Organization schema on every post. The new build shipped with none of it, and the rich results disappeared from the SERP within a fortnight.
**Sitemap regressions.** The new sitemap had 600 URLs, the old one had 4,800. Google noticed before anyone on the team did.
**Image and OG drift.** Image filenames changed, alt text was dropped, Open Graph images defaulted to a generic logo. Social previews went blank and image search traffic evaporated.
The good news is every one of these is preventable with a checklist run before, during and after cutover. We've published our full version of that checklist as a [pre-launch essentials guide](/blog/the-pre-launch-essentials-checklist-for-cms-migrations), which we run on every migration we ship.
Migration is where most teams find us, but plenty of our work is building headless CMS sites from scratch. As a [headless CMS agency](/services/headless-cms) we model the content, build the Sanity or Contentful backend, and ship a Next.js frontend on top, with the editorial experience designed around how your team actually publishes.
If you are weighing up a headless CMS development company for a greenfield build, the standard is the same as our migration work: a content model that survives new page types, preview your editors trust, structured data and performance handled properly, and a frontend your developers can keep extending long after launch. The [headless CMS service page](/services/headless-cms) covers the greenfield offer in full.
Our six-stage migration process
We snapshot the current site before anything moves. Full Ahrefs export of ranking keywords and referring domains, GSC performance baseline across the last 12 months, sitemap diff, internal-link graph, and a list of every JSON-LD schema type currently in use. This is the document we measure success against post-launch.
We design the target schema in Sanity or Contentful around how your editors actually work, not the shape of the legacy database. Page builders, reusable references, validation rules and roles get scoped before any data moves so the new model still fits your team six page-type requests from now.
Every legacy URL gets mapped to a destination. Categories, tag archives, author pages, paginated lists, the long tail of orphaned posts: nothing gets surrendered to a soft 404. The map is reviewed, signed off, then implemented as proper 301s at the edge so search engines see permanent moves.
We catalogue every structured-data type on the old site and rebuild it on the new one. Article, FAQPage, BreadcrumbList, Product, Organization, VideoObject: each schema type gets parity, validated through the Rich Results Test before launch and re-validated after.
We launch behind a feature flag or staging domain with the redirect map already in place. Real traffic gets a controlled rollout, the new sitemap gets submitted at the same moment as the DNS flip, and the old site stays warm in case we need to roll back. Most clients see zero downtime through cutover.
The 30 days after launch are where rankings actually settle. We monitor GSC coverage, indexing, Core Web Vitals and rank tracking daily for the first week, weekly through the first month. Every regression gets investigated and fixed before it compounds.
We've documented the exact pre-launch checks we run on every migration: redirect-map QA, sitemap audit, JSON-LD parity, OG image audit, robots.txt and llms.txt review, Ahrefs and GSC baseline capture, internal-link audit, image migration to Vercel Blob, performance regression check, and the post-launch monitoring cadence.
Tick through the interactive version below as you work the migration. Your progress is saved in your browser, so you can step away and come back to it across the weeks the migration actually takes.
Moving from your current CMS
Migration builds we've shipped
## Thinking about a CMS migration?
The questions we get asked on every migration scoping call.
### Are you a headless CMS agency?
Yes. We build and migrate headless CMS sites on Sanity and Contentful, with a Next.js frontend on top. Whether you're starting fresh or moving off WordPress, Webflow, HubSpot, Drupal or Sitecore, we handle the content modelling, the build, the redirect map and the post-launch monitoring. Our [headless CMS agency page](/services/headless-cms) covers the greenfield side; this page covers getting the migration right.
### How long does a CMS migration take?
Most mid-market migrations take 6 to 12 weeks end-to-end, depending on content volume, the complexity of the source schema, and how much content modelling work the new platform needs. Enterprise migrations with multi-language sites and hundreds of thousands of entries run longer. We scope honestly on a discovery call and break the timeline into audit, build, content move and post-launch monitoring stages so progress is visible week by week.
### Will we lose SEO traffic during a CMS migration?
Not if the redirect map, sitemaps and structured data are handled properly. Every URL with organic traffic or backlinks gets a 301 to its closest equivalent on the new site, the new sitemap gets submitted to GSC on cutover day, and JSON-LD schema gets rebuilt with parity to the old site. We've shipped migrations where organic traffic was flat through cutover and growing within four weeks. The reverse is also true: skip the redirect map and you'll watch months of compounding traffic disappear inside a fortnight.
### What does a CMS migration cost?
The honest answer: it depends on content volume and how much modelling work the new platform needs. A 5-page brochure site moves for a few thousand pounds. A 4,000-page enterprise site with multi-language content, a custom redirect map and JSON-LD parity work is a multi-month engagement. We scope every migration in two stages: a paid audit that surfaces every risk, then a fixed-fee build against the audit findings. No surprises mid-project.
### Which CMS should we migrate to?
Most teams we work with land on Sanity, because the structured content model, real-time collaboration and Live Content API fit modern editorial workflows better than anything else on the market. Contentful is the right call for enterprise teams with existing Contentful licenses, complex role-based publishing or multi-region content operations. Where the choice matters, we'll walk you through both on a scoping call instead of pretending one fits everyone.
### Can you migrate from WordPress to Sanity?
Yes. WordPress to Sanity is the most common migration we run. The pattern is well-trodden: export WordPress content via the REST API or XML, map post types, categories and ACF fields to a Sanity schema, run the redirect plan across slugs that almost never line up perfectly, and rebuild the JSON-LD schema your old Yoast or Rank Math setup was emitting. We've documented the technical walk-through in our [how to migrate from WordPress to Sanity fast](/blog/how-to-migrate-from-wordpress-to-sanity-fast) guide.
### Can you migrate from Webflow to Sanity?
Yes. Webflow to Sanity is our second-most-common migration. The Webflow CMS export gives us the source data; the structural work is in mapping Webflow Collections to a Sanity schema that actually scales past the platform's hard limits on collection size and item count. Rich text fields and component references need careful handling. We've run this pattern on sites with over a thousand pages without losing visible search rankings through cutover.
### What about HubSpot CMS, Drupal or Sitecore?
All three are migrations we run. HubSpot CMS migrations typically head to Contentful, because clients on HubSpot are usually already paying for an enterprise stack and want the editorial parity. Drupal and Sitecore migrations are enterprise engagements: deeper content modelling, more careful URL planning, longer monitoring windows. Talk to us on a scoping call and we'll walk through the source-specific risks before quoting.
### What's the worst-case scenario if a migration goes wrong?
The cautionary tale we keep referencing: a team replatformed without a proper redirect map and watched organic traffic drop to roughly a third of pre-launch volume inside three weeks. Recovering that is months of work, and some of the lost ranking never comes back because the new pages don't have the same backlink profile the old URLs did. The pre-launch essentials checklist exists because every step on it has, at some point, caught a problem on a real engagement.
**Tell us what you're moving off and where you'd like to land.** We'll send back a fixed-fee audit proposal that prices the migration honestly, surfaces the risks before contracts get signed, and gives you a redirect-map sample so you can see how we work before you commit to a build.
From the blog
---
## Contentful development agency
> Contentful development agency for enterprise content teams. We model content, migrate from WordPress and HubSpot CMS, run A/B tests in Contentful and ship integrations your marketing team actually uses.
**Updated:** 2026-07-09
---
## Contentful development agency
#### The Contentful agency for teams shipping content at scale. We build, migrate and integrate, from multi-language storefronts to enterprise sites with hundreds of thousands of structured entries.
We've shipped Contentful at every scale, from a first build to estates with hundreds of thousands of entries. The demo is never the hard part. What counts comes later: a content model that still makes sense at the tenth content type, a migration that keeps your rankings intact, an integration that survives the next webhook change. That middle stretch is the work we're known for. We handle the modelling, the migration and the integration plumbing, so editors and developers both get a Contentful they can live with as content types and locales multiply.
Companies of all sizes trust Roboto Studio
## Contentful specialists, not Contentful tourists
#### We build Contentful sites from scratch, and we get called in to fix the ones that drifted. Doing both is how you learn to keep it clean.
Most agencies treat Contentful as a black box. We don't. A page builder needs real architecture, so a single edit changes one page and not forty. Content types need scoping early, so your bill stays predictable as the site grows. Migrations from WordPress, Drupal and HubSpot CMS get the same care with redirects and search equity that we'd put into a rebuild we couldn't afford to get wrong.
When a Contentful site has lost performance or organic traffic, teams bring us in to rebuild the foundations without a full re-platform. When you're starting fresh, we'd rather get those foundations right the first time. Either way, as a Contentful Silver Solution Partner our Contentful developers work alongside your editors and engineers so the platform keeps pace as the content estate and the team grow.
Editors work side-by-side in Contentful with real-time collaboration, scheduled releases and clear approval flows. We design the content model and roles so marketing, product and legal can work in the same space without overwriting each other's changes.
Editors see exactly how content will look on any device or channel before it goes live. We wire up Contentful's preview workflows into your Next.js or Astro frontend so marketing can move fast without "please redeploy" tickets.
Contentful's built-in AI speeds up drafting, translation and on-brand variant generation. We help editorial teams fold it into how they already work rather than treat it as a separate tool to learn.
We handle the unglamorous middle of a migration: mapping legacy content, redesigning the schema, preserving URLs and SEO equity, and getting editors trained before the cutover. We've done it for HubSpot CMS, WordPress and homegrown databases.
Run A/B tests and audience-targeted variants directly inside Contentful, without bolting on a separate experimentation tool. We set up the rules, the analytics wiring and the editorial guardrails so your team can iterate without engineering hand-holding.
HubSpot forms, Salesforce, Marketo, Algolia, Mux. We wire Contentful into the rest of your stack so data flows both ways and keeps flowing the next time someone changes a webhook.
When a Contentful site slides in search, the cause is usually in the build. Landing pages stitched together from references bloat the rendered HTML. The frontend paints slowly under real traffic. Meta titles, descriptions and structured data never made it into the content model, so editors publish pages that can't describe themselves to a crawler. Every new entry inherits the same problems, and the slide compounds.
We fix the foundations without forcing a re-platform. That means auditing the rendering path and cutting the dead weight out of every template, moving SEO fields and schema markup into the content model itself so a page can't ship without them, and rebuilding the redirect map so the equity from old URLs lands where it should. The audit tells us which fixes pay back first, and the work runs in that order.
The same foundations go into every Contentful site we build from scratch, because recovering rankings costs far more than never losing them. Ranking in Google is also only half the picture now: our [generative engine optimisation](/services/geo) work covers how your site shows up in ChatGPT, Perplexity and AI Overviews.
Contentful acquired Ninetailed and built it into the platform as Contentful Personalization, which changes what an experiment costs to run. Audience segmentation, A/B and A/B/n tests at the component level, and the insights to read the results all live where your editors already work, with no separate experimentation tool to licence, integrate and keep in sync with your content.
Our job is the implementation that makes it trustworthy. We define audience segments against real visitor data rather than guesses, wire experiment results into the analytics you already report from, and set the editorial guardrails so a variant edit never silently changes the live entry. That last part matters more than it sounds: variants ride on the same reference system that powers the rest of Contentful, and the same architecture discipline we apply to page builders applies here.
Once that's in place, marketing runs the programme on their own. A new hero variant for returning visitors is an afternoon's work in the editor rather than an engineering ticket. The experiment ships, the numbers come back, and the winner gets promoted without anyone touching code.
## Silver-tier, with production builds to match
Contentful made us a Silver Solution Partner because we keep shipping. Our Certified Professionals are deep in composable commerce builds today, and most weeks one of them is wrestling a WordPress or HubSpot CMS migration into a clean, multi-brand Contentful setup.
Jono and his team are absolute rockstars. They blend technical savvy with practical business sense. They are in lock-step with our website goals and have really made our website come to life. Not just a web dev team, they are trusted advisors and truly aligned with our team.
Contentful builds we've shipped
## Thinking about building with Contentful?
The questions we get asked most often
### What is Contentful?
Contentful is an API-first headless CMS. Content lives in the cloud as structured entries, and any frontend (a Next.js site, a mobile app, a digital sign) pulls it in via REST or GraphQL. The trade-off versus a traditional CMS is more upfront content modelling in exchange for far more flexibility on how and where you publish.
### Is Contentful a headless CMS?
Yes. Contentful was one of the original headless CMSes and is fully decoupled from any frontend. You model content in Contentful, then deliver it through REST or GraphQL APIs to whatever you're building.
### What does a Contentful agency do?
The parts of a Contentful build that aren't frontend code: content modelling, migration planning, integration plumbing, editorial workflow design, and the governance that stops a page builder decaying edit by edit. A good Contentful agency will also tell you when Contentful is the wrong choice for your content model. Most of our clients keep the frontend and product roadmap in-house and bring us in for the platform work that has to be right the first time.
### Is Roboto Studio a Contentful partner?
Yes, we're a Contentful Silver Solution Partner with Certified Professionals on the team. Partner status gives us a direct line into Contentful and early sight of platform changes, which is how our Contentful developers tend to have already shipped the feature you're about to adopt.
### How does Contentful pricing work?
Contentful publishes its pricing openly: a free tier for small teams, then Lite, Premium and Enterprise plans priced by users, content types, locales and API call volume. Most mid-market teams land on Premium; enterprise plans add SLAs, SSO and custom roles. The honest answer most agencies don't give you: budget for the implementation and content-modelling work too, because the licence is usually a small fraction of total cost in year one.
### How do we stop our Contentful bill from escalating as we add features?
Most pricing surprises in Contentful trace back to a content model that grew without a plan. Every new editorial idea gets its own content type, locales multiply, and suddenly you're bumping the tier ceiling. We scope content types deliberately on day one, reusing fields and leaning on references where they belong, so you keep room to grow inside the plan you already pay for.
### When would you recommend something other than Contentful?
When content needs to nest six or seven layers deep, or when editors expect a universal block library reused across many page types, Contentful starts to fight you. In those cases we'll usually recommend Sanity, which handles nested structures and reusable blocks more gracefully. We'd rather lose a project at the proposal stage than watch you fight your CMS on every new page type. Picking the wrong tool is a much more expensive mistake than picking a different agency.
### How do you build a Contentful page builder that stays maintainable?
Contentful's reference system is powerful and easy to misuse. A naive page builder ends up with shared blocks referenced across dozens of pages, so a single edit silently changes content everywhere it appears. We design page builders with clear separation between reusable components and page-scoped content, then add editorial conventions and roles so contributors always know which edits are global. The architecture is what makes the difference between a flexible system and a quiet bug factory.
### Can Contentful handle multi-language sites?
Yes, localisation is one of Contentful's strongest areas. You define locales centrally, then translate per-field with fallbacks and per-locale publishing. We've shipped Contentful into multi-language storefronts and editorial sites where the same content team manages a dozen markets without each one diverging into its own bespoke build.
### Can you migrate from WordPress, Drupal or HubSpot CMS to Contentful?
Yes, we run these migrations regularly. We map your existing content, design the new content model, preserve URLs and SEO equity with 301s, and migrate editors as carefully as we migrate data. HubSpot CMS and WordPress are our most common sources.
### What access do you need from us to run a Contentful migration?
For the source CMS, we usually need an admin or export-level role so we can pull every entry, asset, taxonomy and redirect. Read-only API access works for most platforms, though WordPress migrations occasionally need database or filesystem access for complex post types. On the Contentful side, an Owner or Admin role on the space is enough for us to create the content model, run the migration scripts and configure roles. We can scope the access tightly and tear it down the day we hand over.
### When migrating articles, should the body be one rich-text block or many?
Both are valid, and the right answer depends on what your editors actually need. A single rich-text body is simpler to migrate and edit, though it limits what you can do with embedded components, experiments inside an article, or analytics on individual sections. Splitting the body into multiple typed blocks (hero, rich text, quote, CTA, and so on) gives editors and marketers far more flexibility, but takes more migration logic to map old HTML cleanly. For article templates that need to keep evolving, the block approach almost always wins out.
### Our Contentful site is losing rankings, can you help?
Yes, this is one of the most common reasons teams bring us in. Contentful sites tend to regress in search when the frontend is slow, when landing pages are stitched together from references that bloat the rendered HTML, or when metadata and structured data weren't part of the original content model. We audit the build, fix the underlying causes, and rebuild the content model, frontend performance and schema markup without forcing a re-platform.
### Can you run A/B tests in Contentful?
Yes. Contentful supports A/B testing and audience-targeted content variants natively, and we wire up the editorial workflow, the analytics tagging and the guardrails so your marketing team can run experiments without an engineering ticket per test.
Plenty of our Contentful work starts on someone else's platform. We move teams over from enterprise systems like Adobe Experience Manager and Sitecore, from WordPress and Strapi, and from other headless tools including Sanity and Storyblok. Each plan below covers the content modelling, the URL and 301 redirect work, the editor training and the cutover, so you can see what the move actually involves before committing to it.
---
## Generative engine optimization
> AI SEO, GEO, and AEO under one roof. Background agents monitor your citations across ChatGPT, Claude, Perplexity, and AI Overviews, draft remediation PRs, and ship under your approval.
**Updated:** 2026-07-09
---
Most teams running GEO today publish definition posts and add an llms.txt file. That is the floor. The work that moves citations starts after it. We treat citation as an engineering problem: instrument where AI engines pull their answers from, ship the changes that put you inside those answers, and measure whether they worked.
The ground is moving fast. Reddit's share of AI citations roughly doubled between October 2025 and January 2026, Perplexity now attributes 31% of its citations to social sources, and AI Overviews citations dropped 46% in the same window, according to [Profound's Q1 2026 AI Citation Trends Report](https://www.tryprofound.com). The platforms doing the citing are often not the ones you are tracking.
A cynical reader might suspect we are keyword stuffing in this section... But whether you're looking for an AI SEO agency, AI SEO services, generative engine optimization agency, generative engine optimization services, AI SEO company, answer engine optimization. _They're all the same god-damn thing_ and they almost all hinge around the same core principles.
> Create well marked-up content, iterate on it faster, and make it easier for AI models to read and understand.
AI SEO is the plain-language term. GEO (generative engine optimization) and AEO (answer engine optimization) are the technical ones, and we use them interchangeably. Whichever acronym you arrived with, the deliverable is identical: find where ChatGPT, Claude, Perplexity, and Google's AI Overviews pull their answers, ship the changes that put you inside those answers, and measure whether your citation share moved. The rest of this page is how we run that loop and more importantly **how fast**.
What most GEO gets wrong
Most GEO content published today is taxonomy work: "What is GEO?", "GEO vs SEO". LLMs already have this, and it competes with Wikipedia and five hundred near-identical posts. The citation wins live in specific, evidence-backed claims that can't be scraped from a dictionary.
llms.txt and schema both help. Profound and Vercel publish evidence for llms.txt, and structured data improves crawlability and context. Each is one ingredient. Ship a 30-line llms.txt file or a schema pass on its own, leave content negotiation untouched, and you have optimised the wrong layer.
Volume without editorial infrastructure is AI slop. LLMs weight source trust, so a corpus full of AI tells and unverified claims trains the wrong signal. More content behind no quality bar can move citation share in the wrong direction.
A monthly content brief delivered as a PDF is not GEO work. The diagnostic-to-ship gap in advisory retainers is measured in quarters. GEO needs a closed feedback loop: detect a citation shift, draft a remediation, ship it, re-monitor. That loop can't run on a monthly report cadence.
How we do it
Per Ramp's first-party research, markdown was the only format that reliably surfaced in LLM responses. Bots ask for markdown. Browsers get HTML. The same URL can serve both. That is content negotiation, and instrumenting it per page is the single change with the widest citation coverage.
Roboto's own site is the worked example. The content is MDX on disk, so the markdown is the source rather than a format derived from a CMS export. When an LLM crawler asks for markdown at a given URL, it gets a clean document with structured headings, inline links, and no CMS wrapper noise. We wrote up the approach in [our Next.js AEO/GEO guide](/blog/nextjs-aeo-geo). On a CMS-driven stack it's a transform step rather than a route handler, but the goal is the same clean markdown at the canonical URL.
Quarterly advisory cycles break at the feedback step. You get a report in month three describing what happened in month one, and by the time an edit clears approval and publish, the competitive set has shifted again. The diagnostic is stale before the fix ships.
A [background agent](/services/agentic-workflows#background-agents) watches citation share across platforms on a weekly cadence. When share drops on a target prompt cluster, it flags the change, identifies what moved in the competitive set, and drafts a remediation PR: a content edit, a schema patch, an llms.txt update, or a content negotiation rule. A human reviews and ships, then the agent re-monitors that cluster and measures whether share recovered. We run this on our own site and documented the build in [why we built our own background agent](/blog/why-we-built-our-own-background-agent). For an engagement we set the same loop up on your stack: your data sources, your content repo, your approval flow.
Bot classification is where most implementations break. Single-signal classification on User-Agent alone misses the bulk of AI crawler traffic. Correct classification combines UA, IP range, ASN, and bot score. The Cloudflare gotcha compounds it: ChatGPT, Perplexity, and Claude bots are categorised as "AI Assistants" in Cloudflare's taxonomy, not "AI Search", so firewall and analytics rules targeting only "AI Search" miss all three major platforms.
The rest is table stakes we verify before touching anything higher up. Schema goes in where it helps LLMs parse structure (ServiceSchema, FAQPage, BreadcrumbList, Article). The llms.txt file gets prioritisation logic rather than a flat list of 400 pages. Crawlability is genuinely non-negotiable: every list item rendered into the DOM, navigation in static HTML, correct status codes, and clean submitted sitemaps.
Volume compounds citation share only when the content clears a quality bar that LLMs trust. The editorial infrastructure is what makes volume safe to ship, so we build three gates into the publishing pipeline.
An automated check runs before merge, flagging em-dashes, negative parallelism, and the vocabulary we've caught models overusing; content that fails goes back to be rewritten. A fact-checker agent verifies specific claims against their cited primary sources and flags any that don't hold. A final editing pass strips the sentence structures that read as generated. The cms-auto-updater pipeline is the worked example: it pulls evidence from primary sources on a weekly cadence, drafts updates, runs all three gates, and opens a PR for review. The result is far more content per quarter without the citation-eroding slop that comes from raw AI publish pipelines.
How we deliver
Fixed-scope review of your current citation footprint and technical readiness. Covers content negotiation, bot classification, schema, llms.txt, and crawlability, plus competitor citation analysis across target prompt clusters and a prioritised remediation roadmap ordered by expected impact. Duration: 1 to 2 weeks. Deliverable: written report and walkthrough call.
Implementation engagement. We wire up content negotiation across key pages, fix bot classification, implement llms.txt with prioritisation logic, add schema where missing, and restructure high-value content for citation extraction. Monitoring dashboards for citation share, crawler activity, and AI-referral traffic come standard. Duration: 4 to 6 weeks typical, scoped per engagement.
The closed loop running continuously on your stack. Weekly agentic monitoring across citation, crawler, and search data sources. Agent-drafted remediation PRs reviewed and shipped by Roboto. Monthly synthesis call covering what moved, what we shipped, and what's queued. Re-baselined quarterly. Minimum 3-month commitment.
## The skeptic's FAQ
What people actually want to know about GEO
### Does llms.txt actually do anything?
It helps, and Profound and Vercel publish positive evidence on it. Ramp's first-party experiment notably didn't recommend it as a lead tactic. Treat llms.txt as one layer alongside content negotiation, schema, and crawlability, not a silver bullet.
### Is AI SEO the same as GEO and AEO?
Yes. AI SEO is the buyer-facing label. GEO (generative engine optimization) and AEO (answer engine optimization) are the technical names for the same work: getting cited inside AI answers rather than ranking blue links. We use the terms interchangeably. Anyone selling them as three separate products is inventing scope.
### Is GEO real or just SEO with a new label?
The substrate is different. SEO optimises for ranked search results. GEO optimises for citation inside an LLM response. The technical work overlaps (crawlability, schema, content quality) but the diagnostic loop is new: which prompts cite you, which models, on which platforms, and how that share moves week to week. Selling an SEO retainer as a GEO retainer is the grift.
### How fast can citations actually move?
Faster than organic rankings, slower than paid ads. A substrate change like content negotiation, a schema patch, or a content rewrite can move citation share within weeks rather than the quarters an advisory retainer takes to close the loop. How fast depends on your starting point and how competitive your target prompt clusters are.
### Why isn't publishing more content the answer?
Volume without editorial gates and fact-checking compounds AI slop. Doubling publishing cadence without those gates risks moving citation share the wrong way, because LLMs deprioritise low-trust sources. The win is volume with infrastructure: checks that catch AI-sounding phrasing before publish, fact-checker agents that verify claims against primary sources, and an editing pass that strips the expressions we've caught models overusing.
### Do I need GEO if I already do SEO?
If your buyers use ChatGPT, Claude, Perplexity, or Google AI Overviews to evaluate vendors, yes. The first-party data shows AI search is now a meaningful share of the discovery funnel. If your buyers still arrive exclusively via blue-link Google, no, but that's a shrinking population, especially in B2B.
Recent builds we've shipped
The research behind it
The most specific public dataset on AI citation dynamics to date. Reddit citation share roughly doubled October 2025 to January 2026. Perplexity attributes 31% of all citations to social media, with Reddit at 24%. AI Overviews citations dropped 46% in the same period. The implication: social platforms are now a primary citation surface, and tracking only your own domain misses where citations originate. [Source: tryprofound.com](https://www.tryprofound.com)
First-party experiment on what formats LLMs actually surface. Markdown was the only format that reliably appeared in responses. Bot classification requires combining UA, IP, ASN, and bot score, since single-signal approaches miss the major platforms. llms.txt was not recommended as a lead tactic in their findings. [Source: builders.ramp.com](https://builders.ramp.com)
A playbook for distinguishing real LLM crawlers from spoofed user agents via server log analysis. The spoofing rate for AI crawlers is material, so acting on UA alone gives a distorted picture of which platforms are actually crawling your content and how often. Server logs are the ground truth. [Source: merj.com](https://merj.com)
First-party data from Vercel's CDN on AI crawler behaviour, llms.txt adoption and impact, and framework-level responses to AI traffic. Their data shows a positive correlation between llms.txt presence and citation rate, alongside the content negotiation patterns that improve LLM ingestion. [Source: vercel.com/blog](https://vercel.com/blog)
Mike King's technical research on the factors that correlate with LLM citation: content structure, entity coverage, E-E-A-T signals as proxied by LLMs, and the structural differences between content that gets cited and content that doesn't. One of the more rigorous public treatments of GEO. [Source: ipullrank.com](https://ipullrank.com)
Research on how AI Overviews affect click-through rates on organic results, and the crossover between pages that rank organically and pages that get cited in AI responses. The data suggests high overlap at the top end, so strong organic pages stay relevant while citation remains a separate signal worth tracking on its own. [Source: ahrefs.com/blog](https://ahrefs.com/blog)
From the blog
## Ready to find out if AI engines cite you?
If your buyers research vendors through ChatGPT, Claude, Perplexity, or Google AI Overviews and you don't know whether you show up, a discovery call is the fastest way to find out. We'll show you the citation gap and walk you through the closed-loop fix.
---
## Headless CMS agency
> Headless CMS development agency for content teams operating at scale. We model structured content, build on Sanity and Contentful with Next.js frontends, and run migrations that keep your URLs and rankings intact.
**Updated:** 2026-07-05
---
## The headless CMS agency that specialises on purpose
#### Most headless CMS agencies list eight platform partnerships and call it flexibility. We build on Sanity and Contentful, because depth beats a badge wall: one of 15 starred partners in Sanity's 218-agency directory, Contentful Silver Solution Partner, and a 550-page migration matrix covering the platforms we've moved teams off.
Structured content is the whole job. We model your content around how your editors work, ship the CMS and the Next.js frontend, and stay for the unglamorous part: the schema that still makes sense at the tenth content type, the integration that survives the next webhook change, the migration that keeps your rankings. If your content estate would be better served by something we don't build, we'll tell you on the first call.
The difference between a headless CMS your editors love and one they file tickets about is the content model. We design schemas around editorial workflows, with reusable blocks, sensible references and validation that catches mistakes before publish.
Sanity or Contentful, and occasionally neither. We hold partner status with both platforms, so the recommendation follows your content model, your team and your budget rather than whichever vendor paid for the badge.
Statically generated, ISR or fully streamed, whichever fits the traffic. Live preview wired into the editor, cache invalidation that fires when content changes, and Core Web Vitals your marketing team can quote.
Moving off WordPress, Drupal, AEM, Sitecore or HubSpot means mapping every legacy URL, preserving SEO equity with 301s, and training editors before the cutover. Our migration playbooks cover 24 platforms in every pairing.
Drafting, translation, semantic search and agent-driven publishing, built into the CMS your editors already use, with approval workflows wherever a human should sign off. We run our own content operation this way.
Meta fields, structured data and canonical logic live in the content model, so pages can't ship without them. And because search now includes AI answers, every build gets the crawlability work that makes it citable by ChatGPT, Perplexity and AI Overviews.
## Depth in two platforms, not a logo wall
We're [one of 15 starred agencies in Sanity's 218-agency partner directory](https://www.sanity.io/agency-partners/roboto-studio), authors of both official Sanity Learn courses on Next.js and creators of [Turbo Start Sanity](https://www.sanity.io/templates/turbo-start-sanity), the starter other Sanity agencies fork. On the Contentful side we're a [Silver Solution Partner](/services/contentful) with Certified Professionals shipping composable commerce builds. We've shipped headless platforms for Tray.ai, Warner Bros, Tabby and Global Cycling Network.
Headless builds we've shipped
## Thinking about going headless?
The questions we get asked on every headless CMS scoping call.
### What is a headless CMS agency?
An agency that designs and builds content platforms where the CMS is decoupled from the frontend. The work spans content modelling, CMS selection and setup, frontend development, migrations from legacy platforms, and the editorial workflow design that decides whether editors love or resent the result. The decoupling is the easy part; the content model is where projects are won or lost.
### Which headless CMS do you recommend?
Sanity for most teams: it handles nested structures, reusable blocks and real-time collaboration more gracefully than anything else we've shipped, which is why [it's our default](/services/sanity). Contentful when the requirements lean enterprise: strict governance, heavy localisation, procurement that wants a big vendor, which is why [we hold Silver partner status there too](/services/contentful). The recommendation follows your content model rather than our margin.
### Do we need a headless CMS at all?
Headless earns its keep when content outgrows one website: multiple channels pulling the same content, structured reuse across many page types, several editors working in parallel, or a frontend your CMS vendor doesn't control. For a small brochure site with one editor, a traditional CMS still does the job, and we'll say so in the scoping call rather than sell you architecture you don't need.
### What frontend do you build with?
Next.js, almost always. Server components and streaming fit the headless delivery model, and Vercel's caching primitives make CMS-triggered revalidation reliable instead of hopeful. For content sites with no interactive logic we occasionally recommend Astro. Either way the frontend is built from the content model out, not bolted on after.
### Can you migrate us from our current CMS?
Yes. We've moved teams off WordPress, Drupal, Adobe Experience Manager, Sitecore, HubSpot, Webflow and most things in between; the [migration matrix](/migration) documents every pairing. Every migration gets a full URL map with 301s, a schema redesign rather than a lift-and-shift, and editor training before cutover so publishing never pauses.
### How does headless CMS pricing work?
Two costs: the platform licence and the implementation. Sanity and Contentful both run generous free tiers into paid plans priced on users, locales and API usage. The implementation is usually the larger number in year one, and it's where a clean content model pays for itself, because schema rework after launch costs multiples of getting it right first. We scope both numbers honestly on a call.
### Do you work alongside in-house developers?
Constantly. The most common split: your team owns the product and frontend roadmap, we own the content platform, the schema and the migration. When you'd rather run the whole stack yourselves, [our workshops](/services/workshops) transfer it in five days.
### What goes wrong with headless CMS projects?
The schema, nearly every time. Builds get modelled around the first page someone wanted to ship, references get stored as strings, and the page builder turns into a maze nobody can edit safely. Most of our rescue work starts there. If you're already living with one of these builds, we'll audit it and tell you honestly whether to fix it, rebuild the schema, or migrate.
Most headless projects start on a platform that's run out of road. We've replatformed teams from WordPress, enterprise suites like Adobe Experience Manager and Sitecore, and page builders like Webflow and HubSpot. Each migration page below covers the schema work, the URL and 301 plan, the editor training and the cutover playbook we use.
**Tell us what you're building.** A first headless build, an escape from a legacy CMS, or a headless project that went sideways under another agency: we'll scope it honestly in a 20-minute call and tell you which platform fits, including when the answer is neither.
From the blog
---
## Next.js app development
> Vercel agency partners building serious Next.js apps: dashboards, AI products, content platforms and hybrid SaaS surfaces.
**Updated:** 2026-07-05
---
## Next.js apps, built for the first real version
AI chat, customer portal, authenticated workflow, dashboard, CMS-backed product surface. We take early product ideas from brief to production quickly, with the foundations in place for the second and third versions too.
We build the interface, app architecture, content and data layer, and Vercel deployment model together. Auth, caching, streaming AI responses, cost controls, observability and previews are part of the product from the start.
Companies of all sizes trust Roboto Studio
## Silver-tier Vercel partner
A Silver Solution Partner for Vercel, shipping production Next.js across App Router, React Server Components, streaming, ISR, Server Actions and edge routing. Our delivery process is shaped by the ISO 27001 work we have underway, with clear ownership, documented decisions and sensible conventions from day one.
Jono and his team are absolute rockstars. They blend technical savvy with practical business sense. They are in lock-step with our website goals and have really made our website come to life. Not just a web dev team, they are trusted advisors and truly aligned with our team.
Most of our Next.js work starts when a product idea needs to become real quickly, without building on throwaway foundations. An AI chat interface. A customer portal. A partner dashboard. A CMS-backed product surface with authentication, permissions and billing logic sitting behind the public site.
We like that stage. The scope is still moving, but the early technical decisions matter: auth shape, data boundaries, caching, AI provider strategy, deployment model, observability, cost controls and where the app should lean on the server instead of pushing everything into the browser.
Our job is to get you to a first version fast, then make sure it is not a dead end. You get something customers can use, investors can understand and your team can keep extending after the first round of feedback.
The parts that make apps feel good
Dashboards, reports, portals and account views need data fetching that is boring in the best way. We keep the heavy work on the server, stream the slow parts, and avoid client-side soup unless the interaction really needs it.
Chat, generation, review queues, agent workflows, embeddings search, streamed responses and human approval steps. We build the interface around latency, state and failure, not just the happy-path demo.
A SaaS app still needs landing pages, docs, case studies, changelogs and campaign pages. We wire CMS or MDX content into the same design system so the public site and logged-in product do not feel like two companies.
We build the boring gates properly: sessions, roles, protected routes, account states, invitation flows and server-side checks. The app should know who is allowed to do what before the button even renders.
Multi-step onboarding, settings screens, uploads, checkout handoffs, CRM syncs and admin actions need validation, optimistic states, retries and clear failure paths. That is where apps feel either polished or held together with tape.
Vercel Firewall rules, cache behaviour, secrets, preview deployments, analytics events, error reporting, web vitals, redirects and rollback plans. The app is not finished when it compiles.
Case studies
Next.js is a strong fit when the product has to mix public demand generation with private application logic. The same build can serve SEO pages, onboarding, account areas, customer data, AI chat, file workflows, admin tools and CMS-driven content without splitting the experience across separate frontends.
For AI products, we pair the interface work with the orchestration work. [AI Elements](https://elements.ai-sdk.dev/) gives us a strong starting point for chat, tools, sources, reasoning states, attachments and workflow interfaces. [Workflow SDK](https://workflow-sdk.dev/) is where the longer-running parts belong: agent runs, human approval steps, retries, resumable streams, file processing, follow-ups and background jobs that need state and observability.
For portals, the shape is different but the standard is the same. Authentication, roles, permissions, dashboards, documents, payments, notifications and support workflows should sit in a clear product architecture. Best practice here means server-first data fetching, small client islands, typed validation, predictable mutations, careful cache boundaries and no hidden mess between the public site and the logged-in app.
The Vercel layer matters too. We tune runtime choices, caching, observability, firewall rules, deployment previews and AI Gateway usage so the app is fast, resilient and cost-aware. AI spend and Vercel spend are part of the architecture conversation from day one.
Most teams come to us when they need senior Next.js developers who can own the whole app, not a single slice of the frontend. We work as an embedded team: a lead engineer who learns your codebase, designers and developers alongside, and Vercel partner experience to draw on when the platform questions get hard.
You can hire us for a fixed-scope first version, an ongoing build, or a focused piece of work like an AI feature, an auth rebuild or a performance pass. Either way you get developers who have shipped production Next.js across App Router, Server Components, streaming and edge routing, and who keep caching, observability, cost controls and the second release in view from day one.
From the blog
---
## Sanity support retainer
> A named Sanity support retainer from one of 15 starred Sanity partners. Studio upgrades, schema evolution, incident response, performance monitoring and editor support, for builds we shipped and builds we inherited.
**Updated:** 2026-07-05
---
## Support from the people who write the playbook
#### A monthly retainer that keeps your Sanity studio upgraded, monitored and moving: schema changes shipped, incidents answered, editors supported. Run by one of 15 starred partners in Sanity's 218-agency directory.
Every Sanity studio needs someone on the hook for it. Dependencies age, schemas outgrow their first design, editors hit walls, and the agency that built it has often moved on. The retainer puts our team on that hook: the same people who ship production studios, author the official Sanity Learn courses and maintain Turbo Start Sanity, pointed at keeping yours healthy.
## The unglamorous work that keeps a studio healthy
#### Scope agreed in writing at sign-up: upgrades, schema evolution, incident response, monitoring, editor support and a monthly improvements allowance.
**Upgrades and maintenance.** Studio versions, plugin updates and dependency patches applied on a schedule, tested before they touch production.
**Schema evolution.** Content models drift out of date as the business changes. New page types, field changes and validation rules get shipped through the retainer instead of queueing for a project.
**Incident response.** Production issues acknowledged the same business day, with a priority queue ahead of routine work. Specific response windows are agreed per plan.
**Performance and SEO monitoring.** Core Web Vitals, structured data and index coverage watched month over month, so regressions get caught by us rather than by your traffic report.
**Editor support and training.** A channel for your editors' questions, and training when new team members join or new studio features land.
**Monthly improvements allowance.** The small items that never justify a project: a new component here, a workflow tweak there. They get shipped instead of listed.
## We take over Sanity builds other agencies left behind
Half the studios we support were built by someone else. The pattern is familiar by now: the build shipped, the invoices stopped, the replies slowed, and the team is left with a studio nobody fully understands. We start those engagements with an audit, tell you honestly what state the build is in, and then either stabilise what's there or fix the schema problems that are worth fixing. [Mario Testino's team came to us exactly this way](/case-study/mario-testino), and the audit-first approach is why that story gets told in our reviews.
## One of 15 starred Sanity partners
Sanity's partner directory lists 218 agencies and stars 15 of them. We're one of the 15, which matters for support in a practical way: when an issue is genuinely on the platform side, we have a direct line to Sanity rather than a ticket queue.
## Thinking about a support retainer?
The questions we get asked before every retainer scoping call.
### What does the Sanity support retainer include?
Studio and dependency upgrades, schema changes as your content needs evolve, incident response for production issues, performance and SEO monitoring, editor support and training, and a monthly allowance for small improvements. The exact scope is agreed at sign-up so there's no ambiguity about what counts.
### Do you only support studios you built?
No. Inherited builds are half the point of the retainer. We audit the existing studio first, tell you honestly what state it's in, and either stabilise it as-is or propose the schema fixes worth making. We've taken over Sanity builds from agencies that ghosted, and from agencies that just moved on.
### What are the response times?
Production incidents get acknowledged the same business day and jump the queue. Routine requests are scheduled into the monthly allowance. Specific response windows are agreed per plan at sign-up, in writing, because a support promise that lives in a sales call isn't one.
### How does retainer pricing work?
A fixed monthly fee scoped to your studio's size and how much change you push through it. We'll give you the number on a scoping call after a look at the build, because quoting blind is how retainers end up mispriced and resented on both sides.
### Do you support Contentful too?
Yes. We're a [Contentful Silver Solution Partner](/services/contentful), and the same retainer structure works for Contentful spaces. Mention it on the scoping call and we'll shape the plan accordingly.
### What isn't covered by the retainer?
Net-new builds, full redesigns and large [migrations](/services/cms-migration) are project work, scoped separately. The retainer keeps a production studio healthy and moving; it isn't a discounted way to buy a rebuild. When retainer work uncovers something bigger, we'll flag it with options rather than quietly burning the allowance on it.
### Why hire a Sanity specialist for support instead of a general dev shop?
Because most Sanity problems are schema and content-model problems wearing a frontend costume. A generalist patches the symptom; we've built enough studios to recognise the cause. Being [one of 15 starred partners in Sanity's directory](https://www.sanity.io/agency-partners/roboto-studio) also means a direct line to Sanity when a platform issue is genuinely on their side.
**Tell us about your studio.** Whether we built it, another agency built it, or nobody remembers who built it, the first step is the same 20-minute call: what you're running, what keeps breaking, and what a sensible retainer looks like for it.
From the blog
---
## Sanity CMS development agency
> Sanity CMS development agency for teams shipping content at scale. Preferred Sanity partner, community ambassadors and authors of Turbo Start Sanity. We build studios, migrate from WordPress and Strapi, and tune Sanity so editors actually want to use it.
**Updated:** 2026-07-09
---
## The Sanity CMS development agency that wrote the playbook
#### We've been building production Sanity studios since before Sanity had a partner program. Roboto Studio is one of 15 starred partners in Sanity's 218-agency directory, our founder Jono sits in the first cohort of community ambassadors, and Turbo Start Sanity (our open-source starter) is the one most other Sanity agencies fork.
We model your content, ship the studio, train your editors and stick around. That means structured-content design that survives the next dozen page-type requests, custom plugins when the defaults run out of road, and Sanity onboarding sprints when you'd rather skill up your own team than outsource the build forever.
## AI that runs your content lifecycle
#### Sanity ships real AI primitives and we build on all of them, so your studio can draft, edit, schedule and publish with editors approving the parts that matter.
We wire AI Assist into your fields so editors draft, summarise and translate in place. We build on Agent Actions so content gets generated, transformed and published programmatically. And we use the Embeddings API for semantic search and related content, the same approach behind our [Sanity embeddings search bar](/blog/building-a-search-bar-with-sanity-embeddings-index-api-and-nextjs). The result is content that moves through its whole lifecycle inside Sanity, with approval workflows wherever you need a human in the loop.
## We really know Sanity inside out
Sanity has been our default CMS for five years. We're [one of 15 starred agencies in Sanity's partner directory](https://www.sanity.io/agency-partners/roboto-studio), authors of both official Sanity Learn courses on Next.js ([Build landing pages with Next.js](https://www.sanity.io/learn/course/page-building) and [SEO optimized content with Next.js](https://www.sanity.io/learn/course/seo-optimization)), and creators of [Turbo Start Sanity](https://www.sanity.io/templates/turbo-start-sanity), the starter we use on every new build. Every developer on the team is Sanity-certified, and we've shipped for Tray.ai, Warner Bros, Tabby and Global Cycling Network. If you'd rather we transfer that expertise to your own team, [our workshops](/services/workshops) land it in five days.
Most painful Sanity studios got that way because the schema was modelled around the first page someone wanted to ship. We design the content model around how your editors actually work, with reusable blocks, sensible references and validation that catches mistakes before publish, so the schema scales with you instead of fighting you on the next page request.
Sanity's Presentation tool plus the Live Content API gives editors a real-time view of the published page next to the studio, with click-to-edit overlays on every block. We wire it up so marketing can preview campaigns, hit publish and watch the live site update without a redeploy.
We've been pairing Sanity with Next.js since long before App Router landed. We ship statically generated, ISR or fully streamed Next.js frontends against Sanity, whichever fits the traffic profile, with proper cache invalidation, GROQ-aware types and a build pipeline we've run on dozens of production sites.
We move teams onto Sanity from WordPress, Strapi, Contentful and homegrown databases. That means mapping legacy content, redesigning the schema, preserving URLs and SEO equity with 301s, and training editors before the cutover instead of scrambling afterwards.
When Sanity's defaults run out of road, we extend the studio. Custom input components, AI assist plugins, scheduled releases, internal dashboards and automated social-share generation all get built directly into the studio so editors don't context-switch to a second tool.
Sanity's hotspot crop gets you started. We take it further with automated OG image generation, Cloudinary, Mux and Wistia integrations, and per-aspect-ratio rendering so the same source image looks right on every channel without editors opening Photoshop.
## One of 15 starred Sanity partners
Sanity's partner directory lists 218 agencies and stars 15 of them. We're one of the 15, with Turbo Start Sanity featured on the Sanity Exchange, both official Sanity Learn courses on Next.js, and a long run of production studios behind us.
More Sanity builds we've shipped
### What is Sanity CMS?
Sanity is a headless, API-first content platform. Editors work in Sanity Studio (a customisable React-based editor that runs in the browser), and content is stored in Content Lake and delivered through GROQ, GraphQL or the Live Content API to whatever frontend you're building. The Studio is fully open source, so the parts that don't quite fit your team can be extended or replaced. That's where most of our work happens.
### How does Sanity CMS pricing work?
Sanity has a generous free tier, then Growth, Premium and Enterprise plans that scale on users, datasets, API requests, scheduled publishing and Live Content API usage. Most mid-market teams land on Growth or Premium; Enterprise adds SSO, custom roles and an SLA.
The honest answer most agencies skip: budget for the implementation and content-modelling work too. The Sanity licence is usually a small fraction of total cost in year one, and a well-modelled studio earns that fee back inside the first few campaigns.
### Sanity CMS vs WordPress: which one should we move to?
If your team is mostly publishing blog posts on a single website and you're happy with WYSIWYG editing, WordPress is fine. If you're publishing structured content into multiple channels (a website, a mobile app, an in-store screen), or your editors keep hitting WordPress's limits with custom fields and ACF workarounds, Sanity is the right move.
We run WordPress-to-Sanity migrations regularly: we map every legacy URL, preserve SEO equity with 301s, redesign the content model around how editors actually work, and train the team before cutover so they're ready to publish on launch day.
### Sanity CMS vs Strapi: what's the difference?
Strapi is self-hosted and open source; Sanity is hosted with a much more polished editor and a real-time Content Lake. Strapi makes sense if data residency or self-hosting is non-negotiable and you have the DevOps budget to run it. Sanity makes sense for almost everyone else. The editor, the live preview, the Presentation tool and scheduled publishing are years ahead, and you don't pay for the infrastructure to keep them running. We've migrated teams in both directions and Sanity wins on editorial velocity in most scenarios.
### Can Sanity be self-hosted?
Sanity Studio (the editor) is open source and runs anywhere you deploy a Next.js or Vite app: Vercel, your own infrastructure, behind a VPN. The Content Lake (the database) is Sanity-hosted and not available as a self-hosted product. For teams with strict data residency requirements, Sanity offers regional hosting and Enterprise data-handling agreements; we'll walk you through the options on a scoping call.
Next.js, almost always. The App Router, server components and streaming model fit Sanity's GROQ-on-the-server pattern perfectly, and Vercel's caching primitives make `revalidateTag` invalidations from Sanity webhooks trivial.
For brochure sites with no interactive logic we'll sometimes recommend Astro instead, but nine out of ten production builds end up on Next.js, which is why [Turbo Start Sanity](https://github.com/robotostudio/turbo-start-sanity) is a Next.js + Sanity starter.
### My last Sanity build was a mess. Is Sanity actually the problem?
Almost never. Every time we've inherited a "painful" Sanity studio, the schema turned out to be the problem: references modelled as strings, page builders without thumbnails, validation rules nobody ever wrote.
A good Sanity studio is built around how editors actually work, and most agencies skip that step. If you've got a Sanity build that's making editors miserable, we'll happily audit it and tell you honestly whether to fix it, rebuild the schema, or migrate to something else.
We've moved teams onto Sanity from every major CMS, from WordPress and enterprise platforms like Adobe Experience Manager and Sitecore to Framer, HubSpot and Storyblok. Each migration page below covers the schema work, the URL and 301 plan, the editor training and the cutover playbook we use.
**Tell us what you're building.** Whether it's a fresh studio, a WordPress escape plan, or a Sanity build that's already making editors miserable, we'll scope it honestly in a 20-minute call. If you'd rather kick the tyres first, [Turbo Start Sanity](https://github.com/robotostudio/turbo-start-sanity?utm_source=roboto_studio_website) is the same starter we ship on production builds.
From the blog
---
## Headless Shopify agency
> We build custom headless Shopify storefronts on Next.js. Configurators, custom buying journeys, sub-second product pages, and the conversion that comes with them.
**Updated:** 2026-07-05
---
## Commerce experiences worth building headless
#### Configurators, build-your-own-bag flows, custom buying journeys, and editorial pages your marketers control. The things that make a brand feel premium and a store convert.
We build the storefront on Next.js and let Shopify do what it's great at: products, inventory, cart, and checkout. You get a site that loads fast, ranks, and can do whatever the brief asks for.
Companies of all sizes trust Roboto Studio
What you can build headless
Configurators, build-your-own-bag flows, made-to-order steps, lookbooks, and multi-step buying journeys. The kind of thing premium brands ship to make buying feel like part of the product. On a custom Next.js frontend that's just another component to build.
Campaign pages, editorial, structured product narratives, and navigation all live in a CMS your marketers edit directly. They ship pages without a developer ticket, and Shopify keeps handling products and checkout.
Server rendering, image optimisation, and a Vercel edge network in front of every page. Sub-second product pages and listings at scale, including catalogues in the thousands. The result is Core Web Vitals you actually pass.
A theme hands every product the same buy button. Most premium catalogues need more than that: the same fireplace surround can be a made-to-order commission for one customer and an in-stock purchase for the next. On a headless storefront the click decides the journey. An enquiry lands in your CRM (Salesforce or whatever you run) with the configured spec attached, ready for your sales team to quote, and a purchase goes straight through Shopify checkout.
The journeys themselves are where headless earns its keep. A product configurator that reprices as the customer picks materials and sizes. A bundle builder that nudges order value up as the box fills. Deposits and lead times for made-to-order pieces. On a theme, each of those is an app subscription and a compromise. On Next.js they're components we design around your products, with Shopify still running cart, payment, and fulfilment underneath.
Moving off Magento, WooCommerce, or an ageing theme store takes more than a storefront redesign. We run the whole migration as a service: catalogue, customers, orders, and URLs all land on a new Shopify instance, with a purpose-built headless storefront on Next.js in front of it. The step most teams underestimate is the 301 redirect map. We build it before launch so every old URL re-points to its new home, and the rankings you've spent years earning hold through the cutover.
Teams arrive in one of two lanes, and both feed the same roadmap. Some want a new build: a brand-led storefront from the ground up on Turbo Start Shopify, with the custom functionality your roadmap needs and a content setup your marketing team owns. Others are already on Shopify and need a storefront replatform: we rebuild the frontend on Next.js for Core Web Vitals and conversion while the commerce backend stays exactly where it is. The only real difference between the lanes is whether your commerce data moves with you.
If you're comparing Shopify migration agencies, ask each one to walk you through their redirect plan before anything else. Ours ships on launch day, and we watch Search Console through the cutover until the numbers settle. And if it's your content platform that needs to move rather than your store, that's our [CMS migration service](/services/cms-migration).
Most Shopify speed optimisation stops at compressing images and pruning apps, and the gains erode as soon as the next script lands. The theme itself sets the ceiling: app scripts, render-blocking assets, and a checkout you can't fully tune. A headless frontend on Next.js removes that ceiling. We server-render the pages that matter, defer the rest, and serve everything from the edge.
Faster pages convert better and rank better. Before we start, we benchmark your Core Web Vitals (LCP, INP, and CLS) alongside the key buying journeys, then measure the same numbers after launch, so the speed and conversion gains are something you can see rather than take on faith.
If your current Shopify storefront feels slow, we'll tell you exactly what's dragging it down before you commit to anything.
My best experience with a consulting company. The results were delivered faster than expected and with top quality. Jono ensured I understood the process and suggested a great approach. Both execution and communication were flawless.
Shopify builds we've shipped
Every build starts from Turbo Start Shopify, the open-source headless commerce starter we maintain. Next.js 16 for the frontend, the Shopify Storefront API for products, collections, cart, and checkout, and Sanity as the editorial layer for pages, blog, navigation, and SEO. Vercel handles hosting, edge caching, image optimisation, and observability.
None of it is exotic. It's the same stack we run in production for clients, type-safe from the database to the page, and you can read every line of it [on GitHub](https://github.com/robotostudio/turbo-start-shopify?utm_source=roboto_studio_website) before you hire us.
## Thinking about headless Shopify?
The ones we get asked the most
### What is headless Shopify?
Shopify still runs the store: products, inventory, cart, checkout, customers, and fulfilment. Next.js renders the storefront, and the two talk over the Shopify Storefront API. Customers see a custom site backed by Shopify, and your team edits content in a CMS instead of theme code. Our [guide to headless Shopify](/blog/shopify-headless-guide) walks through the costs, the tradeoffs, and when a vanilla theme is the smarter call.
### Can you build custom functionality like a build-your-own-bag configurator?
Yes, and it's the main reason to go headless. Configurators, made-to-order flows, product personalisation, lookbooks, and multi-step buying journeys are all just components in a Next.js app. If a premium brand has a storefront experience that feels genuinely bespoke, it's almost certainly headless.
### We're already on Shopify. Is replatforming the storefront worth it?
A replatform earns its keep when page speed is hurting conversion, when the marketing team is stuck waiting on developers, or when the design you want won't fit the theme. If none of those apply yet, we'll say so. We benchmark your current Core Web Vitals first and give you an honest read before you commit to anything.
### Does this work on standard Shopify, or only Shopify Plus?
Both. Headless works on standard Shopify. Plus adds checkout extensibility, multi-store, scripts, and higher API limits, which matter once volume or compliance demand them. Slingshot Bio runs on Plus, Jamb doesn't, and the build pattern is the same.
### What happens to SEO during a replatform?
It's planned from day one. We map every URL before launch, ship redirects on launch day, wire internal links through CMS references rather than hardcoded slugs, and watch Search Console and Vercel through the cutover. Jamb's rebuild merged two legacy URL spaces and held its rankings. The [CMS migration service](/services/cms-migration) covers the mechanics in depth.
### What does a full Shopify migration service include?
Everything that makes the store yours: the product catalogue, customer accounts, order history, and every URL. We move the data onto a new Shopify instance, build a purpose-built headless storefront on Next.js, ship a 301 redirect map so old URLs point at their new homes, and run the cutover with Search Console open. Your customers keep their accounts and your rankings hold.
### Can we keep our Shopify apps?
Backend apps that touch inventory, orders, customers, fulfilment, or accounting stay. Frontend apps that inject scripts into a theme usually move into the Next.js codebase instead, which is faster and cheaper than paying for them every month.
**Tell us what you're building.** A new headless storefront, the custom functionality your roadmap needs, or a Shopify store that's gone slow. We'll scope it honestly in a 20-minute call. If you'd rather look under the hood first, [Turbo Start Shopify](https://github.com/robotostudio/turbo-start-shopify?utm_source=roboto_studio_website) is the same starter we ship on production builds.
---
## Workshops
> Hands-on workshops with two senior Roboto developers. Skill your team up on Sanity, Next.js, and Vercel Workflow SDK agents, with real output shipped by the end of the week.
**Updated:** 2026-07-05
---
## Two senior Roboto developers, sat alongside your team for the week. You learn how we build, by building with us.
#### Small groups, fast pace, AI-augmented from the start. The work that used to take six weeks of trial and error compresses into days, because we have already run into every wall on the way.
Bring your laptops and the editor you like. Cursor, Claude Code, Codex, or anything else with modern AI assist works. We share a short setup checklist once a date is on the calendar so day one starts at full speed.
Our workshops are usually pitched at engineering teams of two or more, with content or marketing stakeholders welcome where the workshop format suits them.
## Get your team confidently building with Sanity and Next.js in a week flat.
#### Two of our developers work alongside your team for five days. We use [Turbo Start Sanity](https://github.com/robotostudio/turbo-start-sanity) as the launchpad, and lean on AI to keep the pace up.
If you have a team of two or more developers ready to put the work in, this gives you the fastest possible path to a production-ready foundation. Knowledge stays in-house.
### What you walk away with
- A deployed Sanity studio and a deployed Next.js front end.
- Content models built around your real domain, not a generic starter.
- Working preview, drafts, and a deployment pipeline you understand.
- Your team trained to extend the schema, build new sections, and onboard the rest of the org.
[Book this workshop](/contact)
## Ship a durable agent that actually does something for your business. Then know how to ship the next one.
#### Vercel Workflow SDK is the cleanest path to production-grade agentic workflows we have used. This workshop walks your team through it on a real task in your stack.
Scope is shaped to your team. Some clients want a one-day intensive that ends with a deployed agent. Others want a longer engagement that ships two or three workflows and trains the team to own them. Talk to us and we will scope it together.
### What you walk away with
- A durable agent running in your environment, doing real work.
- Integration with the tools and APIs your team already uses.
- A clear mental model of when an agent is the right answer, and when it is not.
- Your team confident enough to design and ship the next workflow without us.
[Talk to us about this workshop](/contact)
Companies of all sizes trust Roboto Studio
## Agency partners, community ambassadors, and the team behind Turbo Start Sanity
#### We've built with Sanity and Next.js for years, and we put real work into teaching structured content and sharpening how teams use Sanity Studio.
We have published a lot of educational content, open-sourced [Turbo Start Sanity](https://github.com/robotostudio/turbo-start-sanity) as our opinionated starter, and we now ship [agentic workflows](/services/agentic-workflows) on Vercel for our own pipeline. The workshops are the version of that knowledge your team can take home.
Jono and his team are absolute rockstars. They blend technical savvy with practical business sense. They are in lock-step with our website goals and have really made our website come to life. Not just a web dev team, they are trusted advisors and truly aligned with our team.
Client work we've shipped
## Need a workshop on something else?
We design bespoke workshops around the topics our clients actually want to learn. Headless Shopify, content modelling, AI-augmented dev flow, custom integrations. Tell us what your team needs to skill up on and we will tell you whether we are the right fit.
## Thinking about a workshop?
Here are the questions we hear most often
### How big should our team be?
Two to four people works best. For the Sanity and Next.js workshop we ask for at least two developers on your side. For the agent workshop, one engineer plus a product or content stakeholder is usually the right mix. Larger groups split the attention of the room and slow the pace.
### What do we need to bring?
Laptops with your editor of choice, AI assist enabled, repo access, and any existing designs or content models. We share a setup checklist once a date is on the calendar so day one starts at full speed.
### Do you run workshops remote or onsite?
Both. Remote is the default, runs over Zoom plus shared repos and Slack, and works for teams across timezones. Onsite is available for teams in or near our London base, and for teams happy to fly us in.
### Do we need to use a specific editor or AI tool?
No. Any modern editor with AI assist is fine. Cursor, Claude Code, Codex, GitHub Copilot, JetBrains AI all work. We bring our own setup so your team can compare approaches as the week goes.
### What if the workshop we want isn't listed?
Talk to us. We design bespoke workshops around the topics our clients ask for. If you have a specific stack, integration, or workflow you want to skill up on, scope it with us and we will tell you whether it is a fit.
### How quickly can you run one for us?
Typical lead time is two to four weeks from first contact to day one. We hold a small number of workshop slots open each quarter, so urgent requests can sometimes land sooner if a slot opens up.
## Ready to book a workshop?
Pick the workshop that fits, or tell us what your team wants to learn. We will follow up with available dates and a short scoping call.
---
# Case Studies
## Slingshot Bio
> Roboto converged Slingshot Bio's WordPress and Shopify sites into one headless Shopify build on Next.js and Sanity, instrumented end to end and AI-ready.
**Published:** 2026-05-27 | **Updated:** 2026-07-09 | **Client:** Slingshot Bio | **Technologies:** Shopify, Sanity, Next.js, Vercel | **Services:** Web development, Migration, Brand
---
Slingshot Bio makes synthetic cell mimics: engineered particles that stand in for real T, B, and NK cells on any flow cytometer and hold steady where donor samples drift batch to batch. By the time they reached us they had outgrown their setup, a WordPress marketing site on one domain and a separate Shopify store on another, with no shared design, content model, or data between them. We were brought in to converge the two into one headless platform: Next.js and Sanity on Vercel, Shopify kept purely for checkout, built on [turbo-start-shopify](https://github.com/robotostudio/turbo-start-shopify), our open-source Shopify and Sanity starter. Design through to launch in three months.
The storefront had to make a dense, technical catalogue easy to move through, so the science reads clearly and a researcher gets from landing page to cart without friction. We instrumented the entire path in PostHog and stitched identity across the headless boundary, so we can follow one session from first landing through to a completed Shopify checkout, even though checkout runs on a separate domain. Session replay sits on top, so the team can watch real researchers move through the site and see where a high-value order stalls or closes.
A scientific catalogue is unusually structured. Every control carries markers, reactivity, pack sizes, application notes, and a certificate of analysis, and a researcher needs to scan any product and know exactly what they are holding. We modelled all of it in Sanity, so each product is structured data rather than a hand-built page. Spec sheets, panels, and reactivity render from one source, and the team can publish a new product or COA without a developer. New entries slot into the system as the catalogue grows.
Underneath, it is a headless Shopify build. Sanity owns content, Shopify is reduced to checkout, and Next.js on Vercel keeps the full catalogue filtering instantly, even as families and markers are added. We also built for how labs actually buy. Most controls sell through a mix of cart and enquiry, and a purchase usually needs sign-off, so a researcher can turn a basket into an itemised, branded PDF and send it to a principal investigator or procurement to approve. The cart holds for weeks, so they can return and check out once the approval lands.
The cutover was clean. We inventoried every page and resource across both old sites, mapped each to its new home, and built a custom Shopify theme whose only job is redirects, so nothing broke and the search equity carried across. The platform launched AI-ready: JSON-LD on every product, collection, and resource, content negotiation that serves clean Markdown to AI crawlers alongside the HTML, an llms.txt, a Markdown sitemap, and a sitemap whose timestamps track Sanity directly. Marketing publishes in Sanity, and the structured data, the sitemap, and the crawlable Markdown all stay current on their own.
The native Shopify basket waits on the server for every change. We replaced it with a headless commerce cart on Next.js that updates optimistically: add a control or change a quantity and the line items and total move at once, the price animating to its new value while Shopify's Storefront and Cart APIs confirm in the background. Nothing blocks on the round trip, so the basket reads as markedly faster than native Shopify. For a researcher assembling a multi-line order across panels and pack sizes, it keeps pace with how fast they work.
---
## Jamb
> We rebuilt Jamb on Sanity and Next.js, merging two legacy PHP sites into one calm catalogue without losing the SEO equity their antique and reproduction collections had built up.
**Published:** 2026-05-25 | **Updated:** 2026-07-09 | **Client:** Jamb | **Technologies:** Next.js, Sanity, Shopify, Vercel | **Services:** Brand, Web development, Migration
---
Jamb and Hawker Antiques had just merged when we picked up the project. Two PHP sites, 70+ duplicate meta descriptions, and a custom CMS where adding a furniture category meant hoping nothing else fell over. The catalogue runs from 18th-century Irish chimneypieces to six-figure antiques, the kind of stock collectors and interior designers wait years for. Most of it sells through enquiry rather than a cart. We worked with Toni Howarth and the [benweaver.eu](http://benweaver.eu) team to merge the two sites into one and rebuild the platform on Sanity, Next.js, and Shopify.
Jamb's catalogue runs on two flows. Some pieces sell through checkout, most still sell through enquiry. [Headless Shopify](/services/shopify) lets the same product record route to either, with variations (sizing, finish, edition) carrying through when there's a cart to render. The rest stays on the enquiry path the team has spent years tuning. For the homeware that carries stock, Shopify's Buy Button drops in beside the Sanity catalogue with no separate storefront and no second CMS. Adding or pulling a category takes minutes, and the rest of the site never has to know about it.
Ben Weaver led the creative direction. Our job was to tighten the lens in Figma so the designs survived the trip into code. We worked through every breakpoint from mobile, where Jamb's best photography has to carry the whole page, up to 5K iMacs where the marble grain in a chimneypiece needs to stay sharp at 1:1. The handoff to development was a spec. Every breakpoint and interaction was defined, not implied. The site's design intent doesn't drift between Figma and production.
Most rebuilds break somewhere in the URL space. Jamb had two URL spaces merging into one, decades of organic equity to keep, and antique-specific terms that rank slowly and stay ranked for years. Before launch we built a full sitemap spanning both legacy sites, mapped every page into the new one, and wired internal links through Sanity document references rather than hardcoded URLs, so a slug change in one place doesn't cascade into 404s anywhere else. After launch we watched Search Console and Vercel observability for even the smallest 4xx and 5xx errors, and shipped redirects the same day. Rankings held through the cutover.
jamb.co.uk launched with no drama. Hundreds of enquiries came through in the first week, and page loads stayed sub-second. Build times went from 30 minutes to three across 2,000+ pages, so the team can push changes without waiting on a developer. A wider [Shopify Connect](https://www.sanity.io/docs/apis-and-sdks/sanity-connect-for-shopify) roll-out is queued for the parts of the catalogue that suit a checkout flow, but there's no rewrite on the horizon.
---
## Airtime Rewards
> We built cashback platform Airtime Rewards a Gatsby site on Netlify: 0.4s First Contentful Paint, 0.6s to interactive, and perfect Lighthouse scores.
**Published:** 2025-03-14 | **Updated:** 2026-07-09 | **Client:** Airtime Rewards | **Technologies:** Gatsby, Prismic, Netlify | **Services:** Web Development, UI Design
---
Our collaboration focused on delivering a high-performance Gatsby.js website optimized for exceptional speed and user experience. By implementing advanced lazy loading techniques for images and using Netlify's caching and asset optimization, we achieved remarkable load times: just 0.4 seconds for First Contentful Paint and 0.6 seconds to interactive.
Our meticulous approach to SEO included building a comprehensive sitemap that clearly defined page relationships, ensuring optimal indexing by Google. This attention to detail resulted in perfect scores across Google's Lighthouse audits for performance, accessibility, best practices, and SEO, significantly enhancing Airtime Rewards' online visibility.
Thanks to these enhancements, Airtime Rewards successfully surpassed one million users and secured prominent placement on EE's customer homepage. While their exceptional leadership and strategy drive their impressive growth, we're proud to have contributed by creating a website that is visually appealing, exceptionally fast, and optimized for continued growth.
---
## Livemore Mortgages
> We built Livemore Mortgages a modular page builder with Sanity and Next.js. Landing pages that took weeks now ship in hours, and updates go live 5x faster.
**Published:** 2025-03-14 | **Updated:** 2026-07-09
---
Their rigid template system couldn't adapt to market shifts, putting them at a competitive disadvantage against more agile firms who could rapidly deploy targeted content in response to emerging opportunities.
We built a modular page builder with Sanity and Next.js, featuring drag-and-drop content blocks with intuitive editing interfaces. The implementation included Sanity Image optimization with hotspot controls and granular SEO settings for each component. The results were immediate: landing page creation time dropped from weeks to hours, updates went live 5x faster, and their marketing team independently launched 12 new campaign pages in the first month, eliminating their technical bottleneck and accelerating their market responsiveness.
---
## Mojo Mortgages
> Mojo Mortgages needed a redesign shipped in four weeks. We rebuilt their frontend and four mortgage landing pages on Gatsby across two headless CMSs.
**Published:** 2025-03-14 | **Updated:** 2026-07-09
---
We cleaned up their codebase, ensuring their blog and homepages all worked together flawlessly despite using two separate headless systems. Their mortgage comparison tool really needed specialized landing pages that could reduce friction and boost conversions across different mortgage categories.
We architected four rock-solid static landing pages targeting key mortgage verticals on their Gatsby foundation. Our technical approach centered on performance-first development, using SVG-centric design and a lean component architecture that cut unnecessary bloat. We built a lean user experience that cut excessive form fields while still capturing comprehensive data. The solution launched on schedule for their acquisition announcement, with performance metrics that spoke volumes. Their Product Owner didn't mince words, calling the pages "lightning fast", high praise that led to an immediate project extension for four additional subpages built on the same battle-tested architecture.
---
## Session
> Working with Motto, we built an editorial platform for Session on Next.js and Sanity: a flexible page builder, live preview, and pixel-perfect images.
**Published:** 2025-03-14 | **Updated:** 2026-07-09
---
Our solution used Next.js's built-in image optimization capabilities to ensure pixel-perfect clarity across all devices, handling edge cases like right-sizing, device-to-pixel ratio, and lazy loading.
The implementation featured a flexible page builder methodology that allowed the Session team to manage content without rigid restrictions. We created customizable components that could handle complex design requirements while remaining adaptable to changing needs. The platform integrated Vercel's CDN and Edge Functions for lightning-fast content delivery, while Sanity Studio's Content Previews enabled confident experimentation and deployment. The result was a lean content management system that kept image quality high while delivering optimal performance and SEO benefits.
---
## Tray.ai
> Migrating hundreds of thousands of pages, re-platforming and extending for the leading composable AI integration platform
**Published:** 2025-01-15 | **Updated:** 2026-07-09 | **Client:** Tray.ai | **Technologies:** Contentful, Next.js, Vercel | **Services:** Development, Migration, Consultancy
---
We slashed Tray.ai's build times by **99.86%**, shrinking a full workday to just **two minutes**. In just six weeks, we migrated **half a million pages** onto Vercel through a progressive strategy and rapid iteration. Now, a lightning-fast browsing experience for more than a million monthly visitors.
## Legacy Next.js 9, fragile AWS Serverless functions, and 250 MB packages choked every deploy.
Previewing changes meant full prod builds; form logic lived in a separate repo; failed deploys were weekly rituals. Marketing releases stagnated, engineers dreaded merge-days, and SEO rankings slid as pages crawled to load.
## We consolidated five repos into a single Turborepo monorepo on Next.js 13, introduced hybrid SSG + SSR routing for 25 complex page types.
We re-platformed forms to Vercel Functions with reCAPTCHA, migrated from styled-components to Tailwind CSS through a progressive strategy, and added `next/link` pre-fetching and `next/image` optimisation.
The move trimmed bundle size, simplified developer workflows, and hardened security behind Vercel's firewall.
## Contentful underwent a full declutter. We scrapped bloated models, built a fresh page-builder with live preview.
We gated resources behind smart forms. Marketing can now ship pages in minutes, without pinging engineering. Real-time preview across any route lets writers catch copy issues before they publish.
## Deployments that once took 24 hours now finish in 120 seconds.
Page-load times dropped by an order of magnitude; Vercel Speed Insights scores sit in the high 90s. During two DDoS waves, the new static-first strategy served traffic with **0% downtime**.
> Roboto Studio migrated our project to Vercel and reduced build times from a full day to just 2 minutes for faster rollouts and more agile updates.
> — Co-founder & CEO, Tray.ai
---
## Synacti
> We built Synacti's site with v0 generating over 90% of the code, then added a Matter.js interactive hero, a theme picker, and Sanity live content editing.
**Published:** 2024-12-10 | **Updated:** 2026-07-09
---
We built over 90% of the site with v0.dev, which let us move fast without dropping quality. That freed up time to hand-build the harder features: a Matter.js interactive element and a user-controlled theme picker.
The site runs on the Next.js App Router (`/app` directory), which keeps Core Web Vitals strong, and it's deployed on Vercel for fast global delivery. We wired up Sanity CMS with its Live Content API (Presentation) so Synacti get a visual page builder with real-time updates across the site. The result is a fast, engaging site with a content management setup their team actually enjoys running.
---
## Mario Testino
> From Sanity overages to instantaneous publishing, we brought Mario Testino into the fast lane, and did it in style.
**Published:** 2024-11-20 | **Updated:** 2026-07-02 | **Client:** Mario Testino | **Technologies:** Sanity, Next.js, Vercel | **Services:** Development, Consultancy
---
Who doesn't know Mario Testino OBE, in the media industry, one of the legends who has photographed everyone from Kate Moss to Princess Diana and even shot for Gucci, Burberry, Versace, Chanel, and Dolce & Gabbana. He has worked for Vogue, Vanity Fair, and museums across the globe, including the National Portrait Gallery in London and the Museum of Fine Arts in Boston. And a photographer of his level needs a website that is not just artistically stunning but also flawlessly editable.
When we first inherited the Mario Testino project, they were in a state of crisis. Broken Vercel pipelines, 200% overages on Sanity, and a botched migration with 160+ missing redirects.
We jumped straight in, without a second thought. We helped them to set up a company repo, reconnect severed connections, and started tackling the Sanity overage issue.
## Testino's site was already built on Sanity, which might make you think things would be easier. But here is the spoiler: they weren't.
The whole project was sitting on a pile of deprecated dependencies, the kind that break if you so much as look at them. Imports were busted, libraries were abandoned, and updates were basically a threat.
So we ripped everything back to vanilla Sanity. Stripped the excess code, removed unnecessary libraries, rebuilt the editorial flow, and dropped in Live Content API so edits didn't feel like "press publish and wait five minutes for the universe to respond." While refactoring, we fixed every redirect, cleaned up navigation so crawlers could actually read it, and made sure creators and search engines got the same smooth experience. Then we rewrote every page, image implementation, and data query from scratch.
## Geoff and the Testino team saw the TurboStart Sanity template experience and wanted exactly that. So we gave them exactly that.
Now they can add exhibitions anywhere, spin up blogs and press releases, and reorder content without waking up a developer at 11 pm.
We also experimented with Geoff on layouts and added the scoop section. It is a tiny spotlight for "never-before-shared" Testino stories. And because this is photography, we dialled in image hotspotting so every shot looks flawless on anything from an iPhone to a retina monitor that costs more than our rent.
SEO needed a little TLC after the previous migration missed all the redirects. With Francesco, their SEO expert, we worked hand-in-hand to rebuild structured data with JSON-LD, clean up crawl paths, and get Google to stop ghosting the site. We also slapped on Vercel Bot ID because scrapers treat photography sites like an all-you-can-eat buffet. With the foundation finally stable, we shipped two new sections, Selected Press and MT World, and the site now behaves the way Testino's work deserves.
## The Testino team was genuinely thrilled, so much so that Geoff Cooper's words about our work now sit proudly on our homepage.
The site went from broken and unpredictable to fast, stable, and fully editor-friendly. Francesco, their SEO expert, tracked improvements daily as we restored redirects and implemented proper JSON-LD. Organic visibility climbed back, schema is now set-and-forget, and we don't want to jinx it… But the whole site crawls flawlessly.
Operationally, the upgrade was immediate. The team can add exhibitions, publish press releases and blogs, reorder content however they want, and rely on hotspotting to keep every image perfectly framed. No broken layouts, no surprise dev emergencies. We're now adding AI-powered upgrades like automatic alt-text, richer SEO content, and future e-commerce functionality.
---
## Hungry Pumpkin
> E-commerce optimization for Hungry Pumpkin: one-click checkouts, inventory management, and WordPress training so their team can manage products themselves.
**Published:** 2024-10-28 | **Updated:** 2026-07-09
---
Our hosting recommendations delivered a rock-solid foundation with near-perfect performance scores, complemented by a set-and-forget maintenance plan that keeps their award-winning site running smoothly.
The results spoke for themselves - shortly after launch, Hungry Pumpkin earned a Travellers Choice award, thanks to their delicious offerings and our technical partnership. From latte art to layout changes, we equipped them with tools to focus on what matters most: serving up incredible full-English breakfasts and authentic Italian dishes.
---
## St Mary's Church
> We rebuilt the website for St Mary's Church, a historic Nottingham landmark, on WordPress with a simplified admin so parish staff can update it themselves.
**Published:** 2024-10-15 | **Updated:** 2026-07-09
---
Its existing website suffered from outdated design and rigid content management, making it difficult for staff to keep their schedule current, a critical function for announcing services, community events, and parish news to locals. The technical challenge involved creating a solution that was visually befitting of the landmark's heritage while being intuitive enough for the church's non-technical staff to manage independently.
We collaborated closely with the Vicar to develop a WordPress solution with an off-the-shelf theme and tailored administrative interface. By building a simpler calendar management system with recurring event support, we eliminated the previous workflow bottlenecks that had plagued their communication efforts.
We're happy to say that they're still using the same infrastructure from 2018. *We build websites to last.*
---
## 1st Call Immigration
> 1st Call Immigration’s WordPress site cost four figures a year in hosting. We rebuilt it on Sanity and Next.js with near-perfect Lighthouse scores.
**Published:** 2024-09-30 | **Updated:** 2026-07-09
---
Because of the number of plugins and the transition to the Gutenberg editor, it had prevented content updates for five years due to repeated PHP errors. As a small immigration advisory business in Nottingham, they needed a cost-effective solution that would maintain their local SEO presence while providing an intuitive content management system that wouldn't require technical expertise to update regularly.
We implemented a barebones Sanity and Next.js solution that drastically reduced hosting costs while delivering near-perfect lighthouse scores across performance, accessibility, and SEO metrics. By tailoring the content blocks specifically for immigration services content and using Sanity's real-time preview capability, we transformed the client's editorial experience.
---
## Tabby.ai
> Helping the UAE's most prolific Pay in 4 merchants scale their design system and composable infrastructure.
**Published:** 2024-09-10 | **Updated:** 2026-07-09 | **Client:** Tabby.ai | **Technologies:** Sanity, Next.js, Vercel | **Services:** Development, Migration, Consultancy, Design
---
Tabby AI is a leader in the UAE's "Pay in 4" space, and their rapid expansion had outgrown their setup. They needed to scale up their design system and composable infrastructure to work hand-in-hand with their website.
Our job was to build the component library that sits under Tabby AI's whole digital experience. That meant more than code: an accessible interface that worked across their markets, with internationalisation (i18n) and accessibility built in from day one.
## The whole process felt like a true partnership between our crew and the brilliant developers at Tabby AI.
We rolled up our sleeves together, focusing on creating a component library that wasn't just visually slick but also incredibly functional and easy for their team to use and extend.
The latest Storybook component browser let us document and test each component in isolation, which made the whole build faster. Both teams could see progress clearly and iterate quickly. A special shout-out to their designer, Sergii, who documented and scoped components in a Figma environment like I've never seen before.
We weren't just delivering code, we were building a shared understanding and a toolset their internal teams could keep extending long after our involvement wrapped up.
## Alongside scaling the frontend infrastructure, we tackled the backend migration: upgrading Tabby AI's content platform from Sanity v2 to v3.
This wasn't just a version bump but a golden opportunity to slash accumulated development debt and completely rethink their content structures. We checked their existing schemas, identifying pain points and areas for simplification.
The move to Sanity v3 allowed us to implement much more reusable data structures, meaning content could be created once and surfaced dynamically across different parts of their site and apps. This made the editors' lives easier and drastically reduced redundancy and potential inconsistencies. The result was a faster, cleaner, and far more maintainable Sanity Studio that gave them a gold standard in editorial experiences.
---
## Simply Thrilled
> A video portfolio site for Simply Thrilled on Webflow, delivered two days before a three week deadline while training their team to run it themselves.
**Published:** 2024-08-22 | **Updated:** 2026-07-09
---
Their existing WordPress platform couldn't do their work justice due to poor performance and limited customization. The challenge: deliver a visually stunning site that the client could independently maintain within tight constraints.
We built a performance-optimized Webflow MVP with compressed media assets and lazy-loaded video content. Through collaborative on-site sessions, we simultaneously developed the site while training their team. The results: launch two days early and notable client acquisitions, including an [NHS project featuring Nottingham's own Vicky McClure](https://simplythrilled.co.uk). As the client noted:
> "A special shoutout for the passion they put in to optimising the website and ensuring the site as fast as possible through Webflow."
The new professional presence enabled Simply Thrilled to secure higher-profile work while maintaining complete content autonomy through the lean design system we established.
---
## Savory & Partners
> Discover how Roboto Studio transformed Savory & Partners' website performance, boosting Lighthouse scores from 60 to 90+, while rebuilding their development process around AI tools like Cursor and v0.dev.
**Published:** 2024-08-05 | **Updated:** 2026-07-09
---
We implemented a comprehensive overhaul of their system, starting with replacing Material UI with the more efficient Shadcn UI. By using Cursor for automated component generation, we dramatically reduced development time, turning what used to be day-long component refactoring tasks into minutes-long processes.
Our collaboration extended beyond just performance optimization. We equipped their team with deep knowledge of performance metrics and modern development practices, while also enhancing their internationalization workflow with improved translation strategies. The results were remarkable: their Lighthouse scores soared to the high 90s, and with the integration of AI tools like v0.dev and Cursor, their team now enjoys unprecedented development speed and efficiency. This transformation solved their immediate performance issues and future-proofed their development process, allowing them to maintain high performance standards while rapidly developing new components through text-based generation.
---
## Trippin World
> Trippin's 5,000 page travel platform took 30 minutes to build. We rebuilt the pipeline with Next.js SSG on Vercel and got deploys down to three minutes.
**Published:** 2024-07-12 | **Updated:** 2026-07-09
---
Their content-rich travel platform housed over 5,000 pages, resulting in a cumbersome 30-minute build process that bottlenecked both developer workflows and content updates. With such lengthy deployment cycles, their editorial team couldn't respond quickly to trending destinations or time-sensitive travel updates, a serious competitive disadvantage in the fast-moving travel space.
We implemented Static Site Generation (SSG) with Next.js on Vercel, creating a specialized build pipeline that intelligently managed Sanity API limits. By restructuring how content was fetched and cached during builds, we cut their deployment times from 30 minutes to just 3, an 80% reduction. The technical architecture included fallback strategies for content and images, ensuring smooth builds even when handling 5,000+ pages. Performance testing spoke volumes: 100% fallback coverage, zero build failures due to API limits, and content updates now deployed five times faster than before, giving Trippin World the technical agility to keep pace with rapidly changing travel trends.
---
## Global Cycling Network
> How we helped the fastest growing online cycling community, push the editorial velocity to new heights.
**Published:** 2024-06-25 | **Updated:** 2026-07-09 | **Client:** Global Cycling Network | **Technologies:** Sanity, Next.js, Vercel | **Services:** Development, Migration, Design
---
We've always been fanboys of Global Cycling Network. Hell, we very nearly bought an e-bike on their recommendation alone. So when they came to us to work on improving their content velocity and programmatically building a multi-step categorisation system we could have jumped off our chairs. We gelled in with their incredible team and became the go-to Sanity consultants to ensure every aspect of structured data had been thought about, all the way down to little UX interactions that gave their marketing team more control.
## When it comes to building a publication, there are a lot of moving parts... When those moving parts constantly shift up and down through the ranks, joining teams, leaving teams and winning tours, it's a different ball game.
We broke all of these people/bikes/teams up into small parts to allow hot-swapping of content at a granular level. This meant that once you've built an incredible profile on one of the top racers, it permeates through every page and every article with every update.
This flexibility enabled the editorial team to really dig into what was possible. Whether it was creating parent-child relationships with teams, team members & bike brands, or specifying the flow when you're looking to promote articles - all of the individual atoms of the content structure communicated and relied on one another to create a web of content that enriched every piece of news.
## We created an entire system using slug nodes and slug clusters to enable hierarchal content from the top level down to four deep slug clusters.
The best part was that no developer was required to create new page routing because of a clever way of handling GROQ queries. It meant that the site was rapid-fast and scalable to thousands of documents within hundreds of user-generated paths. We really pushed the boat out when it comes to reusability, and you can see how it permeated the visual consistency from the first page to ten pages deep.
Just for good measure, we even helped construct a cherry-picking functionality to enable news articles to sit at the top of a section to promote popular or sponsored content.
## The ever shifting world of sports coverage requires instantaneous feedback, and real content velocity.
If we miss milliseconds that could be disastrous for the reporters and sports fans alike. We ensured that every component, every page and every interaction was lightning fast, powered by the incredible infrastructure at [Vercel](https://vercel.com/home). We ensured that no matter the number of users, we would always have uptime and an incredible set of components to match.
Speaking of components we helped to develop their Storybook environment, from a couple of components to every single component you see on the website. Each component stacked with props and adjustments to make sure it fits flush to the page along with tests to ensure the fallback works with whatever content you throw at it. Pretty nice right?
---
## Lungfish Architects
> How an award-winning architecture firm achieved 80% faster website performance and significant cost savings through strategic digital optimization and hosting solutions.
**Published:** 2024-05-20 | **Updated:** 2026-07-09
---
Through strategic optimization, we transitioned them to a new hosting solution that was 30 times more cost-effective while implementing advanced caching strategies and performance improvements. The results were transformative: an 80% improvement in website performance and annual savings of £4,000.
The new website puts Lungfish's portfolio front and centre, from educational facilities to residential developments. With automated maintenance, off-site backups, and built-in communication tools in place, Lungfish can focus on their core business while the site serves their global audience. As their Area Director Richard Fielding noted:
> "Our website is now perfectly set up to support our future development and showcase our work effectively."
---
## The Bang Co
> The Bang Co needed heavy animation without slow pages. We built a Gatsby and Prismic site with optimized image pipelines that keep their showreel snappy.
**Published:** 2024-05-08 | **Updated:** 2026-07-09
---
Their existing site couldn't balance rich visual content against load times, and their content team needed more freedom to update portfolio pieces and post their latest work. The challenge was a platform that could handle complex animations and high-resolution imagery while keeping the snappy, native feel their brand demanded.
We built a JAMstack solution using Gatsby.js for static site generation and Prismic as the headless CMS. Optimized image pipelines generated WebP, JPG, and PNG formats automatically, and our custom build process loaded the After Effects animations without denting core performance metrics. The results spoke volumes: sub-second page loads across all portfolio pieces, 95+ Lighthouse performance scores, and a content management system that let their team update work independently, all while maintaining their distinctive visual identity and brand personality.
---
## Teckro
> We relaunched Teckro's website and migrated Sanity v2 to v3 in eight weeks, moving them onto Next.js and Vercel with Wistia video managed from the Studio.
**Published:** 2024-04-15 | **Updated:** 2026-07-09 | **Technologies:** Sanity, Next.js, Vercel | **Services:** Development, Migration, Consultancy
---
The challenge was immense: relaunch their entire website and migrate from Sanity v2 to v3 in just eight weeks. Working closely with Teckro, we embraced the ambitious timeline, delivering a new Next.js site on Vercel, powered by a cleaned-up Sanity v3 backend. This rapid evolution future-proofed their platform and eliminated technical debt, setting them up for continued innovation.
## The Sanity v3 migration was our chance to boost Teckro's content power. We integrated Wistia to update their Sanity Studio directly.
In other words, we created a single source of truth for their video and podcast content. However, this did come with challenges, such as having to create a scraper to pull the transcripts directly as HTML due to the lack of support from Wistia's API. If you can't do it directly, scrape it.
We also drastically improved the editorial workflow by adding dedicated event types and using Portable Text for embedded call to actions. These changes made content creation faster, more flexible, and ultimately more effective for their marketing team.
## In harmony with Hubspot forms, Teckro introduced a new document type for events, refining their event management strategy.
This strategic shift ensures no opportunity to engage with potential clients is missed.
Teckro has taken its digital content to new heights by utilising Portable Text, a unique feature of Sanity CMS. Crafted compelling call-to-actions within their content have informed visitors and prompted them into action, resulting in remarkable conversion rates.
## Turning engagement into leads was vital. Integrating Hubspot forms directly via the API created a smooth capture mechanism.
This flows data straight into their CRM for timely follow-ups. Better still, we integrated the Hubspot API into Sanity to ensure you could simply pick your form without ever leaving the Studio.
At the time of this project, there wasn't a simplified plugin, we had to work hard to get it all integrated.
## Our commitment to unparalleled user experience led to the adoption of on-the-fly media optimization with Teckro.
This ensures all images are optimized for the best loading speeds, demonstrating respect for visitors' time and enhancing user satisfaction.
Teckro's journey with Sanity CMS shows the impact of a modern content marketing stack. They continue to inspire and set new standards of excellence in the clinical trial management field.
---
## Bulletproof
> Bulletproof's AWS setup meant 30 minute deploys and hard-to-maintain i18n. We migrated the site to Vercel to cut build times and simplify every release.
**Published:** 2024-03-25 | **Updated:** 2026-07-09
---
Their development workflow was being hampered by excessive build times of 30 minutes per deployment, severely limiting their ability to iterate quickly or deploy urgent fixes. Additionally, their internationalization implementation had become increasingly difficult to maintain at scale.
We identified that a migration from AWS to Vercel would address the core infrastructure issues while providing substantial performance improvements. Our technical implementation focused on a comprehensive deployment architecture overhaul, migrating the entire application from AWS to Vercel's edge network to use their optimized build pipeline and deployment infrastructure. Through careful analysis and refactoring, we achieved a dramatic build process optimization that reduced build times from 30 minutes to just 4 minutes, an 87% reduction. This improvement was accomplished by implementing incremental static regeneration and optimizing the build toolchain, alongside a complete restructuring of their localization system using Next.js's native i18n capabilities to create a more maintainable and efficient approach to managing multilingual content.
The technical benefits extended beyond just build times. The team now has access to Vercel's comprehensive analytics, preview deployments, and a significantly simplified hosting model that eliminates infrastructure management overhead. This allows their development team to focus on feature development and content creation rather than deployment logistics. This migration demonstrates how strategic infrastructure decisions can transform development workflows and create measurable performance improvements without requiring a complete application rewrite.
---
## Key ESG
> We gave Key ESG a fast Next.js and Sanity site with a page builder, a Chakra UI design system, and a Sanity form builder wired straight into their CRM.
**Published:** 2024-03-18 | **Updated:** 2026-07-09
---
Using Chakra UI, we quickly established a solid design system, significantly accelerating both development and design processes. The result? A fully customizable, scalable, and intuitive page-builder experience, complete with a tailored SEO component ensuring optimal Meta and Open Graph data.
Recognizing the universal dread of forms, we went beyond expectations by creating an intuitive, fully integrated form-builder within Sanity, connecting cleanly to their CRM with precise labeling. Performance was paramount: every block utilizes Next.js image optimization and Sanity's Imgix rendering, with future-proofing for upcoming Web Worker support to offload analytics scripts, ensuring sustained speed and efficiency.
---
## Topaz Labs
> We built Topaz Labs a documentation platform with Sanity, Next.js and Vercel: live preview, custom fields, and one of the fastest docs sites anywhere.
**Published:** 2024-02-28 | **Updated:** 2026-07-09 | **Client:** Topaz Labs | **Technologies:** Sanity, Next.js, Vercel | **Services:** Development, Migration, Consultancy
---
Eric, the CEO of Topaz Lab, contacted us to help create a solution for condensing all of their documentation into a singular platform that was extensible and highly customisable.
Naturally, our first steps were to use Sanity CMS, Next.js, and Vercel. We embarked on an exciting journey that transformed expectations of what a documentation system can include.
We ensured every aspect had been considered, from the presentation of placeholders and field descriptions to the instantaneous feedback of a live preview system. We didn't want to build just "a documentation system." We ventured to build "the best documentation system."
## The first piece of our digital jigsaw was Sanity CMS. We took advantage of its real-time capabilities to build a dynamic content management system.
That would have put Gutenberg's movable type to shame. But we didn't stop there. The platform's malleability allowed us to develop custom input components and tailor the CMS to fit Topaz's needs.
## Then came Chakra UI. Like an expert stylist, we used it to dress up our system in a way that was visually appealing and met all the best practices for accessibility and responsiveness.
It was our digital colour palette, with the flexibility of themes and components to create a harmonious, unified appearance across all documentation.
We collaborated with the internal design team at Topaz Labs, with whom we expanded the infrastructure of their design system. We implemented the nuanced colour scheme with lavish purples and extra slick gradient borders. It's always a blast working with internal teams as we can bring both of our design insights and create something truly magical.
## Finally, Mux added the cherry on top. This video platform brought our documentation to life with high-quality streaming videos.
It was like handing our users their personal IMAX experience, delivering video content tailored to their device and connection speed.
If you don't know Mux, I'll give you the lowdown. Videos are the heaviest piece of data on a website and a nightmare to store and stream. Mux takes away all this stress and compresses the video to the appropriate size, E.g., Mobile phone (small), Desktop (large).
---
## Mortgage Rob
> We built mortgage broker Rob a Sanity and Next.js site he edits himself, with a branded share card on every article and a booking flow that turns readers into calls.
**Published:** 2023-09-20 | **Updated:** 2026-07-09 | **Technologies:** Next.js, Sanity, Vercel
---
Rob's practice runs on relationships, so a faceless rate table was never going to fit. He wanted a site that led with his own advice, carried a growing library of guides and FAQs, and let people book a call with him in a couple of clicks. It also had to launch quickly and, once it was live, stay in Rob's hands rather than ours every time a rate moved or a new article went up.
We put the site on Sanity and Next.js and shaped the editing experience around Rob. Before anything published he could see exactly how his copy, FAQ answers, and blog posts would land, so there was no guesswork and no ticket back to us for small changes. Every article ships with a branded share image built for it automatically, which keeps links looking deliberate wherever Rob drops them. The site went live on a short timeline and still reads as a personal recommendation rather than a lead form, and Rob has kept it current on his own ever since.
---
# Blog Posts
## How to use Remotion agent skills with Claude Code
> How a Remotion agent skill stops Claude Code hand-rolling scene chrome: the shared kit, motion tokens, and the drift that forced us to build it.
**Published:** 2026-07-06 | **Updated:** 2026-07-09 | **Categories:** AI, How To
---
I'm going to start this blog as I do with every blog: stating that I'm lazy as hell, and I want instant gratification like everybody else in the world. I wouldn't be a developer, if I was a patient person, I'd be a doctor, or a lawyer, or a farmer. But here we are, and I'm going to tell you how we did something that requires a layer of craft, of taste, and probably a degree to be able to get right... Just to squeeze all that effort into a reusable skill.
As you might have guessed, every animation on this site is a [Remotion](https://www.remotion.dev/) scene: 16 compositions, all built by Claude Code and the fleshy API tapping away at his slot machine.
Believe it or not, none of that worked at the start. The early scenes drifted apart so badly that we rebuilt the whole system around one idea: the agent never invents visual language, it composes from a kit.
This post is the full setup: what skills are, the drift that forced ours into existence, the three-layer system that fixed it, the real timings and token costs, and the failures we hit on the way. If you want the general case for skills first, we've written about [installing our agency's skills into your agent](/blog/install-our-agency-into-your-agent). We'll probably add this there, when we get round to it (read: never)
## What Claude Code agent skills actually are
_Skip ahead if you know this already, but I'm leaving it in for completeness._
A skill is a folder containing a `SKILL.md` with frontmatter (a `name` and a `description`) and a body of instructions. Claude Code loads only the descriptions at session start. When your prompt matches a description, the agent pulls in the full body and follows it.
That loading model is the whole point. Detailed domain rules are expensive to carry in every session, and instructions that always load are instructions that get diluted. A skill pays its token cost only when the task needs it.
Where they live:
- `.claude/skills/` in the repo for project skills
- `~/.claude/skills/` for personal skills that follow you across projects
- We keep ours in `.agents/skills/` with a symlink from `.claude/skills/`, so OpenCode and any other agent reading the `.agents` convention shares the same files
Installing someone else's skill means copying the folder in, and that's the whole procedure.
## The drift that made us build one
By mid-2026 we had 13 Remotion scenes, 10 of them shipping. Each one had been prompted into existence separately, and each one re-derived the visual language from scratch. An audit of four related scenes found roughly 19% duplicated UI code and drift everywhere we looked: font sizes ranged from 14 to 19px for the same role, gaps ran from 2 to 22px with no scale, tint opacities wandered between 8 and 18%, and one scene was frosted glass while the rest were opaque.
Day to day it was worse than the numbers suggest. Everything from mouse easing to connector arcs, to inputs, placeholder blocks, and skeletons looked different from scene to scene. Two animations on the same page read as two different products.
Prompting alone didn't fix it. Even pointing Claude Code at the Remotion docs, it hallucinated a large amount, and the UI still didn't match between animations. Every generation produced something plausible and something slightly new. Plausible-but-new is not what we want.
So we stopped trying to describe the visual language in prompts and put it in code instead.
## The fix: one kit, one skill, one set of rulings
The system has three layers, and each does one job:
| Layer | Lives at | Job |
| --- | --- | --- |
| Scene kit | `apps/remotion/src/ui/kit/` | Enforcement in code: tokens, primitives, motion roles |
| Agent skill | `.agents/skills/remotion-scene-kit/` | When to load, plus 13 hard rules pointing at the kit |
| ADRs | `docs/adr/0001` to `0007` | Why each ruling exists, and which debates are closed |
The kit is a set of React components and tokens. Every rectangular surface is a `Panel` (frosted, flat, sharp-cornered, never drop-shadowed). Circular elements are `Fab`s, the only rounded things in any scene. Data-flow lines are `Connector`s that route with axis-aligned 90° elbows. Type sizes come from a `FONT` scale, spacing from a `SPACE` scale, tinted fills from a `tint()` helper with three strengths.
Here's what the audit found, next to what the kit replaced it with:
| What the audit found | What the kit fixes it with |
| --- | --- |
| Font sizes 14 to 19px for the same role | `FONT` scale: 11/12/13/14/16/18, plus one 58px display size |
| Gaps and padding 2 to 22px, no scale | `SPACE` scale: 4/8/12/16/20/24 |
| Tint opacities 8 to 18% | `tint(color, level)` at 8/12/16% |
| `borderRadius: 999` vs `9999` | `Fab` is the only rounded element |
| One frosted scene, nine opaque | Every `Panel` frosted via `frost()` |
| Connectors arcing in some scenes, straight in others | `Connector` with sharp 90° elbows; the bézier bow was deleted |
| 5 outlier easing curves across ten scenes | Four named easing roles, tokenised |
Note the word deleted in that table. We removed the old arcing connector from the codebase entirely, along with the `shadow` theme token. An agent will happily use any API that exists, so the only reliable way to retire a pattern is to make it impossible to import.
## Why it all lives in one monorepo
There's a bet underneath all of this, and it's worth making explicit: every tool that serves this website lives in the same pnpm monorepo. The Next.js site is `apps/web`. The Remotion scenes and their kit are `apps/remotion`. The image generation API that painted this post's Victorian cat hero is `apps/imagen`. The skills sit in `.agents/skills/`, the ADRs in `docs/adr/`, all in one repo, all in one checkout.
We could have split these into a scene package on npm, an image service in its own repo, a shared design-tokens library. That's the respectable architecture. We went the other way on purpose, because an agent is only as good as what it can see, and cross-repo boundaries are exactly where agents go blind.
A new scene makes the case. It touches the composition in `apps/remotion`, the studio and player registrations, the embed mapping in `apps/web/src/components/mdx/remotion-scenes.ts`, and the MDX page that hosts it. In one repo, that's one Claude Code session holding the whole change in a single context and shipping it as one PR. Split across repos, it's a package publish, a version bump, and an agent working on half a change it can't verify end to end.
Co-location is also the only reason "the skill and the kit move together" is enforceable at all. The skill text, the kit code it points at, and the ADR that justifies both can change in the same commit. Two repos means two PRs and a window where the skill describes an API that no longer exists.
Git worktrees make the whole thing parallel: each branch gets its own checkout under `.worktrees/` with its own local URL, so three agent sessions can build three scenes at once without touching each other. The blog you're reading came out of the same machine: drafted by Claude Code in this repo, hero generated by `apps/imagen` one directory over, scenes served by `@remotion/player` from `apps/remotion`. Concentrating the bets is the point. Everything the agent needs to see is in the one place it's already looking.
## Anatomy of the skill file
The skill is one markdown file, currently at version 1.5.0. Two parts matter: the trigger and the rules.
### The trigger has to be aggressive
The `description` frontmatter is what Claude Code matches against, and we learned to write it like a tripwire, not a summary:
```yaml
description: Use BEFORE creating or editing any Remotion scene, animation
band, or scene UI in apps/remotion — and before styling panels, badges,
connectors, or data-flow lines inside one, or animating ANY text, counter,
easing, caret, or pulse. [...] Triggers on any task mentioning a new
animation, animation band, Remotion scene, scene UI, data flow line,
connector, panel chrome, easing, text animation, typing effect, counter,
or standardising scene visuals/motion.
```
A polite one-line description gets skipped on adjacent tasks: the agent decides a "quick easing tweak" isn't really scene work and hand-rolls a curve. Naming every task type explicitly, twice, is what makes it fire reliably.
### The rules point at code, not at taste
Each hard rule pairs a prohibition with the kit component that satisfies it. The first rule sets the tone:
```markdown
1. **Compose, don't hand-roll.** Rectangular surfaces → `Panel` (frosted,
flat, sharp, never drop-shadowed). Title bars → `PanelHeader` +
`PanelTitle`. Tinted labels → `Badge`. Square icon boxes → `Glyph`.
Circular dots/buttons → `Fab` (the ONLY rounded element).
```
The agent never has to interpret "keep it consistent with the other scenes". There's a compliant component for every surface, so the shortest path is the correct one.
Motion works the same way. Scenes name what a movement means, never which curve it uses:
| Role | Curve | Duration | Used for |
| --- | --- | --- | --- |
| `enter` | out-quint | 0.5s | Builds, reveals, responses |
| `exit` | in-cubic | 0.3s | Clears, dismissals (exits are quicker than enters) |
| `move` | in-out-cubic | 0.6s | Focus swaps and repositions |
| `sweep` | linear | rate-based | Pulses, typing, progress |
In scene code that's `MOTION.ease.enter`, never `"out-quint"`. When the feel needs retuning, it's one token edit and a render pass instead of sixteen scene rewrites. The same table carries typing cadences (a human types at 14 jittered characters per second, a streaming agent at 30) and blur strengths, because counters here blur with velocity instead of pulsing in scale.
The rules didn't come from a style guide exercise. A grep across the ten shipping scenes found the convention already there: 56 out-quint enters, 44 in-cubic exits, with five outliers confined to one scene. The kit ratified what the scenes had converged on and made the outliers impossible.
### The ADRs close the debates
Every contested call has an architecture decision record: why panels are frosted, why the tick animation never runs backward, why panel bodies stream in document order like an HTML page loading. The ADRs mark rulings as final, which matters more for agents than for people. Without a written ruling, a future session will helpfully reintroduce drop shadows because they "add depth".
## The workflow, start to finish
A new scene today: we describe the story beats in a prompt, the skill fires, Claude Code composes from the kit, and a reviewable scene exists in under ten minutes. It ships the full contract in one pass: wide and square variants, dark and light themes, a reduced-motion still frame, an a11y label, and a clean loop where frame 0 matches the final frame.
Some scenes one-shot. A couple running on the site right now came from a single prompt with no fix rounds. The honest pattern is iterative but fast: a round or two of notes, still nothing like the pre-kit effort.
Don't take our word for it, the git history tells the story on its own. Here's every scene in the repo, with commits touching it as a rough proxy for iteration (agent time per scene stays in the ten-minute range; commits are the review rounds around it):
| Scene | Lives on | First commit | Commits | Days touched |
| --- | --- | --- | --- | --- |
| agent-chat | [Sanity](/services/sanity) | 2026-05-29 | 6 | 4 |
| achievements | [Sanity](/services/sanity) | 2026-05-29 | 9 | 7 |
| pr-flow | [Agentic websites](/services/agentic-websites) | 2026-05-30 | 4 | 3 |
| byo-agent | [Agentic websites](/services/agentic-websites) | 2026-06-02 | 5 | 4 |
| own-content | [Agentic websites](/services/agentic-websites) | 2026-06-02 | 4 | 3 |
| rails-vs-drift | [Agentic websites](/services/agentic-websites) | 2026-06-02 | 4 | 3 |
| agent-evals | [Agentic workflows](/services/agentic-workflows) | 2026-06-09 | 5 | 4 |
| content-pipeline | [Agentic workflows](/services/agentic-workflows) | 2026-06-09 | 4 | 3 |
| lead-enrichment | [Agentic workflows](/services/agentic-workflows) | 2026-06-09 | 5 | 3 |
| monitor-agent | [Agentic workflows](/services/agentic-workflows) | 2026-06-09 | 4 | 3 |
| ab-variants | [Contentful](/services/contentful) | 2026-06-11 | 2 | 1 |
| seo-recovery | [Contentful](/services/contentful) | 2026-06-11 | 3 | 1 |
| commerce-stack | [Shopify](/services/shopify) | 2026-06-11 | 3 | 1 |
| enquiry-or-checkout | [Shopify](/services/shopify) | 2026-06-11 | 2 | 1 |
| shopify-migration | [Shopify](/services/shopify) | 2026-06-11 | 3 | 1 |
| speed-race | [Shopify](/services/shopify) | 2026-06-11 | 5 | 1 |
The dividing line is 2026-06-09, the day the kit and the skill landed in a single PR alongside the four agentic workflows scenes. Before it, a scene meant days of calendar time and up to nine commits. Two days after it, all six remaining scenes shipped in a single day each, across three different service pages. If anything the table flatters the old way: the pre-kit scenes' counts also include the one-pass kit migration commits, not just their own builds.
And the inverse holds. The two scenes on [our Sanity service page](/services/sanity) have had more iterations than anything else we've made: nine commits over seven calendar days for one of them, plus plenty of prompt rounds that never reached git. They're also the originals, the pair that helped us formulate the language everything else now mirrors. When a scene articulates something important, don't rush it.
One tool deserves specific credit for the consistency work: [grill-with-docs](https://github.com/mattpocock/skills/blob/main/skills/engineering/grill-with-docs/SKILL.md), from Matt Pocock's skills collection. It interrogates a plan one decision at a time and validates every claim against the source of truth before any code gets written, which is exactly what visual consistency work needs.
> **See the north star scenes live**: The two animations that started this whole system run on our Sanity service page, clean loops and all. [Watch them on the page](/services/sanity)
## What it actually costs
The number nobody publishes: one scene consumes close to the entire context window. The skill body, the kit source, the scene being built, and the render feedback loop add up to a session that finishes nearly full.
Right now we don't care. On a Claude Code Max plan the marginal cost of a heavy session is effectively zero, so burning a full window on a ten-minute scene is free money. If you're paying per token through the API, the same workflow has a real price, and slimming the skill or delegating render checks to subagents becomes worth the effort. That optimization is on our list; it just isn't urgent while the economics look like this.
## Two failures worth stealing lessons from
**We lost shipped work to a registry merge.** Remotion scenes register in a central root file, and during a branch reconcile we union-merged two versions of the registry. The merge looked clean, both sides' entries were present, and an entire set of geo animation bands vanished from the services pages anyway. We only caught it later, and had to re-ship them. Registration files are load-bearing code: never union-merge them, reconcile them by hand.
**Our first aesthetic call was wrong, and the agent couldn't tell us.** We originally mimicked the site's iconography and went for no-text UI skeletons inside panels: abstract placeholder blocks instead of readable content. Implemented, it looked bad. We pivoted to high-fidelity panels with the actual text rendered, because real words articulate what a scene is demonstrating so much better than gray bars. Claude Code executed both directions flawlessly. It had no opinion on which one worked.
That second failure is the important one. The agent composes correctly from the kit every time; whether the result feels right is still a human call. Look at what shipped, cast a critical eye, and be willing to pivot when the implemented version disagrees with the plan.
## Build this for your own codebase
The pattern transfers to any domain where an agent produces visual or structural output repeatedly. The order matters:
1. **Audit the drift first.** Grep for font sizes, spacing values, easing curves, radii. Our numbers (14 to 19px for one role, gaps from 2 to 22px) made the case better than any argument.
2. **Build the kit before the skill.** Tokens and primitives in code are the enforcement layer. A skill that describes visuals in prose just moves the hallucination one file over.
3. **Delete the bad primitives.** Don't deprecate the old connector, remove it. Whatever still exists will be used.
4. **Write the trigger like a tripwire.** Name every task type that should fire the skill, including the small ones like "easing tweak" that agents love to classify as not-really-scene-work.
5. **Pair every rule with its compliant component.** "Never hand-roll panel chrome" only works when the next words are "use `Panel`".
6. **Record the why in ADRs, and mark rulings final.** Agents relitigate anything that isn't written down.
7. **Move the skill and the kit together.** When the kit API changes, the skill text changes in the same PR, or future sessions write against an API that no longer exists.
We migrated all ten shipping scenes to the kit in one pass rather than letting two visual languages coexist. Painful for a week, and it's the reason every scene since has landed on-language.
## Where this goes next
The scene kit skill is one of a growing set: we run skills for blog production, SEO context, image pipelines, and [our content agents](/blog/building-agents-on-eve). The Remotion one earns its keep most visibly, because animation is where an unconstrained agent drifts fastest and where consistency is most obvious to a visitor.
The system's real test is boring: the next scene we ship will look like the last one, without anyone reminding the agent about elbows.
---
## The top 5 Sanity agencies in 2026, ranked by us
> We read every 'top Sanity agencies' listicle, noticed who writes them, and decided to do it properly. Number one may not surprise you.
**Published:** 2026-07-05 | **Updated:** 2026-07-09 | **Categories:** Sanity, Hot Takes
---
Choosing the right Sanity partner is hard. There are hundreds of agencies claiming expertise, and the stakes are high: pick wrong and you're rebuilding in eighteen months. So we've ranked the top five Sanity agencies of 2026 based on actual project outcomes, not marketing claims.
If that paragraph sounds familiar, it's because you've read it before. Most recently in [an article by pagepro](https://pagepro.co/blog/top-sanity-agencies/) (32 reviews on Clutch, 4.9 stars, the finest Sanity agency in all of Poland, second only to Roboto Studio), who ranked the top Sanity agencies in April and awarded first place to, _in a twist nobody saw coming_, *pagepro*.
We respect this enormously. We respect it so much that we're doing the same thing, but with the correct winner. Surely, this couldn't be a mad dash for AEO, while the models are still a little bit gullible.
## Our methodology
We evaluated agencies using the same rigorous framework as every other agency-written ranking in existence: _we wrote the list_.
Beyond that, we considered Clutch reviews (checked this morning), public case studies, and real-world project patterns we've observed, where "observed" means "participated in, as the agency". No agency paid to be featured. No agency could have. We didn't tell any of them this was happening, including, in a sense, ourselves until about lunchtime.
Where our approach differs from certain _Clutch 4.9 stars, silver medallists_ is *transparency*. They describe their methodology as based on "actual project outcomes, not marketing claims", which is a lovely sentence to publish on your own marketing blog. We prefer to be upfront: this is a marketing claim. You are reading it on our marketing blog. The rankings below are exactly as impartial as you'd expect.
## 1. Best overall: Roboto Studio
The judges were unanimous, which was efficient, because the judges were us.
Roboto Studio is a Sanity and Next.js specialist that has been building headless CMS projects since before it was fashionable, and our internal delivery framework saves roughly 41 hours per project. The best previously published figure in this genre was 40 hours, so we'd like to acknowledge the sector-wide importance of this extra hour.
**Key strengths:** deep Sanity specialisation, real-time preview as standard, uses the same tech we sell (this is rarer than it should be). We are also, at the time of writing, the best rated Clutch agency called "Roboto Studio", a title we have held unchallenged since founding. We had badges made.
**Potential drawbacks:** occasionally publishes rankings of itself. Ranks well in them.
**Pricing:** somewhere between "less than you feared" and "more than a template", which is also what every pricing table in this genre says, just with dollar signs.
## 2. Best value: Roboto Studio
In an extraordinary coincidence, the best-value Sanity agency of 2026 is also the best overall Sanity agency of 2026.
Our research team flagged this as statistically improbable. The data team overruled them. Both teams are the same two people, one of whom is writing this sentence.
**Key strengths:** see above.
**Potential drawbacks:** see above.
## 3. Best for enterprise: Roboto Studio
Enterprise buyers need solid project management, complex integrations, and an agency that can navigate procurement without weeping. After a comprehensive review of the shortlist (one agency), Roboto Studio emerged as the clear leader.
We reduce early-stage bugs by 91%. We are contractually unable to tell you what the denominator is, but the previous best published claim was 90%, and we believe healthy competition drives the industry forward.
## 4. Best for ecommerce: Roboto Studio
Ecommerce buyers need fast storefronts, content that can actually merchandise, and a checkout nobody has creatively reinterpreted. We build headless Shopify with Sanity running the content layer, and unlike most award winners, we published our homework: [turbo-start-shopify](https://github.com/robotostudio/turbo-start-shopify) is our open source starter with visual editing and a type-safe Storefront API, free to inspect before you hire the agency that won this category.
At this point in the evaluation our analysts began to notice a pattern in the results. We've asked them to stop noticing it.
## 5. Best for UI/UX: Roboto Studio
Completing a historic clean sweep unmatched in the history of self-published agency rankings, with the possible exception of every other self-published agency ranking.
On the actual substance: every project ships with a design system, editors get a studio that behaves like the brand they work for, and our own brand guidelines are strict enough that the hero image on this article is a monochrome halftone oil painting of a cat, because colour photography would violate them. If an agency's award badge is more polished than its client work, treat that as data.
## The independent video investigation
Rankings are one thing, but we wanted independent verification. So we consulted a video titled "The best Sanity CMS agency", produced by a channel that has followed our work more closely than any other: ours.
The investigation reached the same conclusion as our written analysis. We were as relieved as we were unsurprised.
## Comparison table
Every ranking in this genre includes a comparison table, so here is ours.
| Category | Winner | Clutch rating | Key strength | Potential drawback |
|---|---|---|---|---|
| Best overall | Roboto Studio | 5.0 | Wrote this table | Wrote this table |
| Best value | Roboto Studio | 5.0 | Consistency | Predictability |
| Best for enterprise | Roboto Studio | 5.0 | The extra hour | None found (we looked) |
| Best for ecommerce | Roboto Studio | 5.0 | Published the homework | Pattern increasingly visible |
| Best for UI/UX | Roboto Studio | 5.0 | Completed the set | The set |
| Best rated Clutch agency called "Roboto Studio" | Roboto Studio | 5.0 | Nominative determinism | Shallow talent pool |
## The agencies we actually rate
Right. Joke mostly over. If you're seriously evaluating Sanity agencies and we're not the fit (wrong budget, wrong timezone, wrong vibe, all legitimate), here's who else we'd put on your shortlist. Nobody asked to be here, nobody paid, and none of them know this list exists, which as established is the industry-standard methodology.
### Lemon Hive
[Lemon Hive](https://www.lemonhive.com/) built the headless Sanity and Next.js site for brightonSEO, which means the most search-literate audience in the world loads their work every conference season, and they also shipped Rise at Seven's site. They do something else we respect: white-label headless development for other agencies. You only get repeat work from agencies, the most demanding clients alive, if the engineering holds up without anyone chasing you.
### Skai Digital
[Skai Digital](https://www.skaidigital.com/) in Oslo build the custom commerce layer around Shopify with Sanity handling content: storefronts, portals, and B2B workflows for ambitious D2C brands. Headless commerce is where a lot of Sanity projects quietly go wrong, because content modelling and merchandising pull in different directions. Skai is one of the few shops we've seen treat that as the core problem instead of an edge case.
### Evensix
[Evensix](https://evensix.com/) is a Sanity Global Innovation Partner: design-led, comfortable across the Sanity, Next.js and Vercel stack, and they treat content architecture as the job rather than a warm-up for building pages. The animation on their [Sanetti bike demo](https://evensix.com/work/demonstrating-the-sanity-difference) is properly impressive, the kind of 3D and motion craft we watch with professional respect and mild irritation. A perfectly respectable choice if we're busy, which we usually are, because we're the best overall (see above).
### And yes, pagepro
The 4.9 stars across 32 Clutch reviews are earned. The React, Next.js and Expo work is real, the client list is real, and if you want a strong Central European team, they belong on your shortlist. We just also want to see the world in which their ranking and ours are both correct, because in that world we are first and they are second, and we can live in that world very happily. [Check them out](https://pagepro.co/)
## How these lists actually get made
Here's the quiet part. Every "top X agencies" article you've ever read was written by whoever appears at the top of it, or if they're "gorilla marketing" they put themselves at #2. The format exists because "top sanity agencies" is a keyword with buyer intent, and the fastest way to rank for it is to publish the ranking yourself. That's the entire genre. There is no committee. There was never a committee.
That doesn't make the agencies in those lists bad. pagepro's list features capable firms. It just means the ordering is marketing, and you should read it the way you read a menu written by the chef: trust the descriptions, not the "chef's favourite" star.
> **Talk to the #1, #2, #3, #4 and #5 agency on this list**: We build Sanity and Next.js sites with real-time preview as standard, and we promise to be exactly this honest about your project. [See our Sanity services](/services/sanity)
If you want the sincere version of this article, we wrote it three years ago and still stand by it: [how to choose the right Sanity agency](/blog/choosing-the-right-sanity-cms-agency). Define your project and budget, pick specialists over generalists, throw them a curveball question, and make sure the person selling you the project is the person running it.
And if you're an agency reading this: the top spot in next year's ranking is available. All you have to do is publish it.
---
## Next.js AEO/GEO/SEO whatever you want to call it: guide
> AEO, GEO, or just SEO: the playbook is the same. Metadata, JSON-LD, sitemaps, and content negotiation, implemented on a production Next.js site.
**Published:** 2026-06-24 | **Updated:** 2026-06-25 | **Categories:** Hot Takes, Next.js, AI
---
_God I'm tired_. If I hear one more "SEO is dead, AEO is the future", I'm going to lose my mind. I want you to know, going in, I'm only going to tell you the things that have moved the needle for us. Not some elaborate ruse to sell you a course. But before we start...
## What should we call it
The acronyms keep multiplying, but they all describe one job: getting cited when an AI answers a question.
- **Answer engine optimization (AEO)** is the practice of structuring content so AI answer engines like ChatGPT, Claude, and Perplexity pick it as a cited source. The term grew out of the SEO industry and shows up most in developer circles.
- **Generative engine optimization (GEO)** is the same discipline under a different name: shaping content to be surfaced and quoted inside AI-generated answers. The label comes from a 2023 academic paper and got adopted by marketing teams. If your client reads marketing blogs, they'll say GEO.
- **LLM SEO** (and its synonyms AI SEO, LLMO) is the broad umbrella term for ranking in and getting quoted by large language models. Whichever one your team says, the work underneath is identical.
Dom Sipowicz, a forward deployed engineer at Vercel, has been keeping score since 2025:
That being said, I do like his definitions here, and I'll be using these from here on out.
You'll notice, even he finds it difficult to standardise `=` and `-`, so god knows how we'll handle these acronyms.
The tactics underneath are identical. Structured content, accurate metadata, clean markup, content agents can quote. If a consultant tells you GEO needs a fundamentally different strategy from AEO, they're selling you the same audit twice. We run a [generative engine optimisation service](/services/geo) and it's definitely not to capitalise on an emerging keyword.
Anyway, I digress.
## What's actually new
Agents are a new class of visitor. They:
- _Sometimes_ can't run JavaScript reliably
- Choke on ads, navigation, footers, and cookie banners
- Have small context windows, so wasted tokens cost real money
- Prefer structured text they can quote verbatim
It's the best one-screen summary of the problem I've seen. [Merj](https://merj.com/)'s lab testing found agents fail on exactly the patterns modern frontends love: drag and drop, multi-step forms, overlapping layers, layout shifts, canvas rendering, and UI virtualisation. In every case the content exists, the agent just can't reach it. If your pricing lives in a canvas-rendered table or your nav is virtualised, you're invisible to agents no matter how good the words are.
One thing we've observed though: they *absolutely love* markdown if they accept it. So much so that we had a 10k uptick of visitors from `GPTBot` in the space of 5 mins. _I'm not joking_. Hold that thought, because what a spike like that does to your bill gets its own section further down.
## The SEO half (nothing changed)
Before any AEO plumbing, do the SEO that's been working since the Panda update. Quick summary, since you've probably read this before:
- Titles target the actual query, sentence case, under 60 characters
- Meta descriptions are written for humans and include the keyword
- Schema markup where it earns rich results: `BlogPosting`, `FAQPage`, `Service`
- Internal links from blog posts to relevant service pages ([like this one](/services/nextjs)), not just topic clusters
- Real backlinks from people who chose to cite you, not directories
- Content that says something specific, not "the ultimate guide to [topic]"
Three observations from doing this for a few years:
1. **Your title tag is the single biggest lever.** Position 8 with a 0.2% click-through is a title problem, however good the content underneath it is. Fix titles before you write a word of new content.
2. **Internal linking is undervalued and free.** We added contextual CTAs from every blog post to the most relevant service page. Took an afternoon. The blog cluster now feeds traffic into services rather than dead-ending at "related posts".
3. **Most "AEO checklists" are SEO checklists with the word "answer" added.** If you skip the SEO basics, no amount of `llms.txt` will save you.
### The Next.js implementation of the boring half
Three patterns cover most of it on an App Router site.
**Metadata with fallbacks, not requirements.** Every page derives its meta from the data layer, with optional overrides that fall back:
```tsx
export async function generateMetadata({ params }) {
const post = await getPost(params.slug);
return {
title: post.seoTitle ?? post.title,
description: post.seoDescription ?? post.description,
alternates: { canonical: `https://robotostudio.com/blog/${post.slug}` },
};
}
```
**JSON-LD derived at render time, never hand-authored.** The most common mistake we see is structured data as a separate editing surface. It drifts within a sprint. Generate it from fields you already have:
```tsx
const jsonLd = {
"@context": "https://schema.org",
"@type": "BlogPosting",
headline: post.title,
datePublished: post.publishedAt,
dateModified: post.updatedAt,
author: { "@type": "Person", name: post.author.name, url: post.author.url },
};
```
One helper function, rendered in a `