Switch from Webflow / Framer to Next.js: GEO-Optimized
Why the switch matters, how to set up the CMS, and how to connect it with Claude Code to create new pages in minutes. A complete migration guide for AI search visibility.
No-Code (Webflow / Framer)
Next.js
The Problem with No-Code Platforms
| Issue | Webflow / Framer | Next.js |
|---|---|---|
| Performance | Larger bundles, slower TTFB | Optimized output, automatic code-splitting |
| SEO Control | Limited meta tags, basic structured data | Full control over head, Schema.org, sitemap |
| Geo-Optimization | Not possible natively | Middleware for geo-routing, built-in i18n |
| Scalability | Platform limits (CMS items, bandwidth) | Unlimited scalability |
| Vendor Lock-in | Export = chaos | Your own code, portable anytime |
| Custom Logic | Very limited | Full programming freedom |
| AI Visibility (AEO) | Limited structured data control | Full Schema.org, API endpoints for AI agents |
Webflow serves server-rendered HTML and Framer pre-renders (SSG) published pages. Basic content is crawlable. The limitations above apply to dynamic elements, granular rendering control, and advanced customizations that become critical at scale.
What is Next.js?
Next.js is a React-based full-stack framework by Vercel. It combines:
Server-Side Rendering (SSR)
Pages rendered on the server for faster load times and better SEO
Static Site Generation (SSG)
Pages generated at build time for maximum performance
Incremental Static Regeneration (ISR)
Static pages updated in the background without re-deploy
App Router
File-based routing with React Server Components
API Routes
Backend logic in the same project
Edge Runtime
Code runs on edge servers worldwide
Where Does Figma Fit?
Figma is a design tool, not a website builder. The workflow is:
Figma (Design) -> Next.js (Code) -> Vercel (Hosting)
Figma stays in the stack as the design source-of-truth. The handoff to Next.js happens via developer implementation or AI-assisted tools like Claude Code.
Real Performance Benchmarks
Sources
Data based on publicly available benchmarks from:
- WebPageTest
- web.dev Core Web Vitals documentation
- DebugBear: Webflow Performance (2024)
- Calibre: CWV Benchmarks (2024)
TTFB and Core Web Vitals (Typical Ranges)
| Metric | Webflow (Standard) | Framer (Published) | Next.js SSG (Vercel) |
|---|---|---|---|
| Median TTFB | 400-800ms | 200-600ms | ~50-80ms |
| P95 TTFB | 800-1,400ms | 600-1,100ms | ~80-120ms |
| First Contentful Paint | 1.5-2.5s | 1.2-2.0s | ~0.5-0.8s |
| Largest Contentful Paint | 2.5-4.0s | 2.0-3.5s | ~0.8-1.3s |
| Total Blocking Time | 200-400ms | 150-300ms | ~10-30ms |
| HTML Size (gzipped) | 60-100KB | 80-130KB | ~8-15KB |
| JS Bundle Size | 250-400KB | 350-500KB | ~30-60KB (page-level) |
Methodology: Ranges reflect typical production deployments on standard tiers. Webflow Enterprise with Cloudflare CDN can achieve ~200ms TTFB. Framer SSG pages perform better than dynamic Framer pages. Next.js values assume Vercel Edge Network with SSG. ISR and SSR routes will have higher TTFB. Test your own pages at webpagetest.org or PageSpeed Insights.
Feature Matrix
| Feature | Webflow | Framer | Next.js |
|---|---|---|---|
| Visual Editor | Yes | Yes | No (but CMS UI available) |
| Geo-based Routing | No | No | Yes (Edge Middleware) |
| i18n / Multilingual | Limited (Localization available since 2023, but restricted) | Limited | Yes (built-in via next-intl) |
| Custom Structured Data | Basic (manual per page) | No custom markup | Full control (JSON-LD per route) |
| API Endpoints | No | No | Yes |
| Edge Computing | No | No | Yes |
| A/B Testing | Limited | Limited | Yes (Edge Middleware) |
| Any Headless CMS | Limited | Limited | Yes (any CMS) |
| Git-based Workflow | No | No | Yes |
| CI/CD Pipeline | No | No | Yes |
AI Crawler Behavior
GPTBot, PerplexityBot, and Google-Extended crawl sites differently than traditional search bots. They prefer clean, server-rendered HTML and skip content that depends on JavaScript execution or user interaction.
Major AI Crawlers
| Crawler | Operator | Behavior | JS Rendering? |
|---|---|---|---|
| GPTBot | OpenAI | Crawls HTML for training data & ChatGPT citations. Respects robots.txt. | No. Reads raw HTML only |
| PerplexityBot | Perplexity AI | Indexes pages for real-time search answers. Follows links aggressively. | Limited. Prefers SSR |
| Google-Extended | Feeds Gemini/AI Overviews. Separate from Googlebot. | No. Separate from rendering pipeline | |
| ClaudeBot | Anthropic | Crawls for Claude's knowledge. Respects robots.txt. | No. HTML only |
| Applebot-Extended | Apple | Feeds Apple Intelligence features. | No. Raw HTML only |
What AI Crawlers Can Miss on No-Code Pages
Basic static content on Webflow/Framer pages is crawlable. The issues below apply to dynamic or interactive elements:
Dynamically loaded content
Content loaded via JS after initial page load (filtered lists, paginated sections) may not be visible
Interaction-gated content
Tabs, accordions, and carousels that require clicks to reveal content are never expanded by AI crawlers
Lazy-loaded sections
Content behind intersection observers or scroll triggers never loads for crawlers that don't scroll
iFrame embeds
Embedded forms, videos, and third-party widgets are completely opaque to AI crawlers
Next.js SSG Solution:
Every page is pre-rendered at build time as complete HTML. AI crawlers receive the full content, structured data, and semantic markup on the very first request. No JavaScript execution needed.
Geo-Optimization with Next.js
What is Geo-Optimization?
Adapting content and experiences based on the user's location:
Language
Automatically detect and switch
Currency
Localize pricing
Content
Show regional case studies, testimonials
Compliance
GDPR for EU, CCPA for US
CDN Routing
Serve content from nearest edge server
Implementation with Next.js Middleware
Note: SCAILE uses next-intl middleware with URL-prefix routing (/en/, /de/). The example below shows an optional extension for geo-based auto-redirect.
import { NextRequest, NextResponse } from 'next/server'
export function middleware(request: NextRequest) {
const country = request.geo?.country || 'US'
const locale = country === 'DE' || country === 'AT' || country === 'CH'
? 'de' : 'en'
if (!request.nextUrl.pathname.startsWith(`/${locale}`)) {
return NextResponse.redirect(
new URL(`/${locale}${request.nextUrl.pathname}`, request.url)
)
}
} i18n URL Structure
scaile.tech/services -> English (default)
scaile.tech/de/services -> German
-> Separate meta tags, Schema, OG tags per language
-> Hreflang tags auto-generated
-> Shared components, locale-specific content Edge CDN Delivery
Latency: < 50ms worldwide (vs. 200-500ms single-origin)
CMS Architecture
Why Headless CMS?
A headless CMS delivers content via API. The frontend (Next.js) is completely decoupled. This means you can swap the CMS without touching the frontend, and vice versa.
Choosing Your CMS
Keystatic / MDX
Use Keystatic or MDX if you want Claude Code to directly create and edit content files in Git (fastest content production workflow).
Sanity
Use Sanity if you need a visual editing experience for non-technical team members, real-time collaboration, or a media library.
Payload CMS
Use Payload if you want everything self-hosted with full TypeScript integration.
Content Structure Example (Git-based)
content/
├── blog/ # Blog articles (Markdoc/MDX)
│ ├── my-article/
│ │ └── index.mdoc
│ └── ...
├── case-studies/ # Case Studies (YAML)
│ ├── client-name/
│ │ └── index.yaml
│ └── ...
├── team/ # Team profiles (YAML)
│ ├── first-last/
│ │ └── index.yaml
└── jobs/ # Job postings (YAML)
└── ... blog: collection({
label: 'Blog Posts',
slugField: 'title',
path: 'content/blog/*/',
format: { contentField: 'content' },
schema: {
title: fields.slug({ name: { label: 'Title' } }),
date: fields.date({ label: 'Date' }),
category: fields.select({
label: 'Category',
options: [
{ label: 'Go-To-Market', value: 'gtm' },
{ label: 'AI in Sales', value: 'ai-sales' },
{ label: 'B2B SEO', value: 'b2b-seo' },
],
}),
excerpt: fields.text({
label: 'Excerpt', multiline: true
}),
content: fields.markdoc({ label: 'Content' }),
},
}) Content Structure Example (Sanity)
export default defineType({
name: 'blogPost',
title: 'Blog Post',
type: 'document',
fields: [
defineField({
name: 'title',
title: 'Title',
type: 'string',
validation: (Rule) => Rule.required(),
}),
defineField({
name: 'slug',
title: 'Slug',
type: 'slug',
options: { source: 'title' },
}),
defineField({
name: 'category',
title: 'Category',
type: 'string',
options: {
list: ['gtm', 'ai-sales', 'b2b-seo'],
},
}),
defineField({
name: 'content',
title: 'Content',
type: 'blockContent',
}),
],
}) CMS Comparison for Next.js
| CMS | Type | Price | Best For | Claude Code Compatible? |
|---|---|---|---|---|
| Keystatic | Git-based | Free | File-based content, full Git control, zero external dependencies | Excellent (reads/writes files directly) |
| Sanity | Headless API | Free up to 20GB | Flexible schemas, real-time editing, media library | Good (via API) |
| Contentful | Headless API | Free up to 25K records | Enterprise, multi-channel delivery | Moderate (API-based) |
| Strapi | Self-hosted | Open Source | Full control, own infrastructure | Good (local API) |
| Payload CMS | Self-hosted | Open Source | Next.js native, TypeScript-first | Good (local API) |
| MDX/Markdown | File-based | Free | Blogs, docs, technical content | Excellent (direct file editing) |
GEO Optimization Capabilities
Next.js enables automatic Schema.org markup, granular rendering control, full i18n support, and programmatic sitemaps. These capabilities are either limited or require workarounds on No-Code platforms.
Server-Side Rendering for AI Crawlers
// Every page is pre-rendered, no client JS needed
export default async function BlogPost({ params }) {
const post = await getBlogPost(params.slug) // Build time
return <Article>{post.content}</Article> // Complete HTML
}
// All pages pre-rendered at build
export async function generateStaticParams() {
const posts = await getAllBlogPosts()
return posts.map(post => ({ slug: post.slug }))
} Internationalization
Automatic Sitemap, RSS, Feeds
// Auto-generated from content files:
/sitemap.xml -> All pages, all locales
/feed.xml -> RSS for blog (EN)
/feed-de.xml -> RSS for blog (DE) Schema.org Deep Dive
Structured data is the language AI models use to understand your content. Below are production-ready Schema.org templates.
Article Schema
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "Your Article Title",
"description": "Concise summary for AI snippets",
"datePublished": "2025-01-15T08:00:00+01:00",
"dateModified": "2025-01-20T10:30:00+01:00",
"author": {
"@type": "Person",
"name": "Author Name",
"url": "https://yoursite.com/team/author"
},
"publisher": {
"@type": "Organization",
"name": "SCAILE"
}
} FAQ Schema
Critical for AI citations. FAQ Schema directly feeds into ChatGPT answers and Google AI Overviews.
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is AI Engine Optimization?",
"acceptedAnswer": {
"@type": "Answer",
"text": "AEO is the practice of optimizing content
so AI models cite your website as a source."
}
}
]
} Service Schema
{
"@context": "https://schema.org",
"@type": "Service",
"name": "AI Visibility Content Engine",
"provider": {
"@type": "Organization",
"name": "SCAILE",
"url": "https://www.scaile.tech"
},
"serviceType": "AI Search Optimization"
} HowTo Schema
Perfect for guides and tutorials. AI models use this to generate step-by-step answer formats.
{
"@context": "https://schema.org",
"@type": "HowTo",
"name": "How to Migrate from Webflow to Next.js",
"step": [
{
"@type": "HowToStep",
"position": 1,
"name": "Audit Existing Content",
"text": "Export all pages, document URL structure."
},
{
"@type": "HowToStep",
"position": 2,
"name": "Set Up Next.js + CMS",
"text": "Initialize project, configure collections."
}
]
} Claude Code Integration
Since Next.js projects are code and content files in a Git repo, Claude Code can directly create, edit, and optimize everything -- turning it into a zero-UI content production tool.
Workflow Examples
Once your CLAUDE.md is configured, Claude Code creates the file, fills frontmatter, writes structured content, adds FAQ section, and places internal links. After git push, the page is live with full Schema markup.
> "Create a new blog post about AEO for SaaS companies.
> Category: b2b-seo. Write 2,500 words with FAQ section." Claude Code creates all 5 files in one pass. In Webflow, this would be half a day of manual CMS entry.
> "Create 5 blog posts for these keywords: [list].
> Each 1,500+ words, category gtm, with FAQ section." > "Update the case study: Add new metric -- +350% AI Citations" The CLAUDE.md File (Project Context)
A CLAUDE.md file in the project root gives Claude Code permanent context about your project conventions.
# Content Creation Rules
## Blog Posts
- Always in content/blog/{slug}/index.mdoc
- Frontmatter: title, date, category, author, excerpt
- Minimum 1,500 words
- FAQ section at the end (auto-converts to Schema)
- Internal links to /services, /case-studies where relevant
## GEO Rules
- Every page needs a clear answer to a question
- First paragraph = Direct answer (for AI snippets)
- Schema markup is auto-generated from content structure Time Comparison
| Task | Webflow/Framer | Next.js + Claude Code |
|---|---|---|
| New page | 2-4 hours | 10-30 minutes |
| Design change | 30-60 minutes | 5-15 minutes |
| New language | Days | 30-60 minutes |
| SEO optimization | Manual per page | Automated |
| Structured data | Manual/impossible | Automated |
Recommended Tech Stack
Minimum Viable Stack
Next.js 15 (App Router)
TypeScript
Tailwind CSS v4
Keystatic (free, git-based) or MDX
Vercel (free tier)
Vercel Analytics
Claude Code
Full Production Stack
Next.js 15 (App Router)
TypeScript
Tailwind CSS v4
shadcn/ui (Radix Primitives)
Sanity v3 or Keystatic
Vercel Pro
Vercel Edge Network (automatic)
Vercel Analytics + PostHog
Resend
React Hook Form + Zod Validation
NextAuth.js / Clerk (if needed)
Sentry
next-sitemap + JSON-LD (built-in)
next-intl
next/image + CMS image pipeline
Claude Code
GitHub -> Vercel (automatic)
Migration Playbook
Phase 1 -- Audit
- List all existing pages and content types
- Export content (Webflow: CMS Export, Framer: manual copy)
- Document URL structure for 301 redirects
- Identify Schema markup gaps
- Benchmark current Core Web Vitals
Phase 2 -- Setup
npx create-next-app@latest my-site --typescript --tailwind --app
npm install @keystatic/core @keystatic/next - Configure CMS collections and content schemas
- Set up i18n (if multilingual)
- Build base layout (Header, Footer, Navigation)
Phase 3 -- Design System
- Use Figma designs as reference
- Configure Tailwind with brand colors, fonts, spacing
- Build base components: Button, Card, Section, Typography
- Claude Code can generate components from Figma screenshots
Phase 4 -- Content Migration
Migration order:
- Homepage
- About / Team
- Services
- Blog (with CMS)
- Case Studies (with CMS)
- Contact
- Legal (Imprint, Privacy)
Claude Code handles ~80% of content conversion when given the exported content as input. Human review required for accuracy and brand voice.
Phase 5 -- GEO Optimization
- Schema.org templates for every content type
- FAQ Schema automation
- Breadcrumb Schema
- OG tags and meta per page and locale
- Sitemap and RSS feeds
- Internal linking strategy
- Middleware for geo-routing
Phase 6 -- Testing & Launch
redirects: async () => [
{
source: '/old-webflow-path',
destination: '/new-path',
permanent: true, // 301 redirect
},
] - 301 redirects for all old URLs
- Lighthouse audit (target: 90+)
- Cross-browser testing
- Update Google Search Console
- DNS migration
- Monitor: crawl errors, 404s, Schema validation
A temporary ranking fluctuation (2-4 weeks) is normal during any migration, even with perfect 301 redirects. Most sites recover and improve within 4-8 weeks thanks to better TTFB and structured data.
Migration Case Study
B2B Analytics SaaS - Anonymized Example
Mid-market SaaS company with 45 pages on Webflow CMS. Goal: become the cited source for "B2B analytics" queries in ChatGPT and Perplexity.
Before (Webflow)
- 0 AI citations per month
- TTFB: 820ms average
- No structured data (Schema.org)
- Client-rendered CMS content
- 45 pages, 3 languages (broken)
- Content production: 2 posts/month
- No Schema.org markup
- Monthly cost: $2,800
After (Next.js, Week 12)
- 42 AI citations per month
- TTFB: 58ms average
- Full Schema on all 85 pages
- 100% server-rendered (SSG)
- 85 pages, 2 languages (native i18n)
- Content production: 12 posts/month
- Full Schema.org on all pages
- Monthly cost: $35
Timeline Breakdown
Week 2
Migration complete, live on Next.js
Week 6
First AI citations appear (8 total)
Week 12
42 monthly AI citations, 85 pages
Before vs. After
| Capability | Webflow / Framer | Next.js + CMS + Claude Code |
|---|---|---|
| New blog page | 30-60 min (manual CMS entry) | ~10 min (Claude Code + review) |
| Schema markup | Manual, error-prone | Automatic, template-based |
| SSR / SSG | Basic (Framer: SSG, Webflow: server-rendered, but no per-route control) | Full control -- static, SSR, or ISR per route |
| AI crawler compatibility | Basic content crawlable, dynamic elements missed | Complete (pre-rendered HTML, full Schema) |
| Internationalization | Webflow Localization (limited), Framer (workaround) | Native, clean routing via next-intl |
| Bulk content production | Hours per batch (manual) | Minutes per batch (Claude Code + review) |
| Version control | None or limited | Git -- every change tracked |
| CMS cost | $20-50/month | $0 (git-based) or $0-99/mo (headless) |
| Vendor lock-in | Yes (platform-dependent) | No (open source, portable) |
| Geo-based routing | Not possible | Built-in (Edge Middleware) |
Who Should Switch?
Switch Now If:
- AI visibility (AEO/GEO) is a business goal
- You have 20+ pages or regular content production
- Multilingual support is needed
- Bulk content production is planned
- Schema markup control is important
- You want to reduce vendor dependency
- You need geo-based content delivery
Stay on No-Code If:
- Pure brochure website (5 static pages, rarely updated)
- No technical team available and no Claude Code access
- Content changes less than once per month
- Design iteration speed matters more than performance
TL;DR
Webflow and Framer are design tools. Next.js + Headless CMS + Claude Code is a content production engine.
The switch takes ~2 weeks. After that: new pages in minutes instead of hours, full GEO/AEO control, lower platform costs, and a system that scales with AI-powered content production.
FAQ
Do I need to know how to code to use this stack?
For the initial setup (~2 weeks), you need a developer. After that, ongoing content production is largely prompt-driven via Claude Code, and non-technical team members can use the CMS visual editor (Keystatic or Sanity Studio).
Will I lose my Google rankings during migration?
A temporary ranking fluctuation (2-4 weeks) is normal during any site migration, even with perfect 301 redirects. Proper redirect mapping, canonical tags, and Search Console monitoring minimize the impact. Most sites recover and improve within 4-8 weeks thanks to better TTFB and structured data.
Can I still use a visual editor?
Yes. Both Keystatic and Sanity provide visual admin UIs. You get the best of both worlds: a visual editor for non-technical users and direct file/API access for developers and Claude Code.
How does this compare to WordPress?
WordPress can achieve similar results but requires extensive plugins (Yoast, WP Rocket, WPML), a managed host, and ongoing maintenance/security updates. The Next.js stack is faster out of the box, has lower ongoing costs, and has zero plugin dependencies.
What about e-commerce?
Next.js works with headless commerce platforms (Shopify Storefront API, Saleor, Medusa). You get full Schema control over Product, Offer, and Review markup -- critical for AI shopping results.
How do I measure AI citations?
Tools like Otterly.ai, Profound, and manual monitoring of ChatGPT/Perplexity responses for your brand keywords. This is an emerging space -- no single tool covers everything yet. Track citations weekly and correlate with content changes.
Why Keystatic over Sanity (or vice versa)?
Keystatic is free and git-based -- Claude Code can directly create/edit content files, making it the fastest for AI-assisted content production. Sanity offers a richer visual editor, real-time collaboration, and a media library -- better for teams with non-technical content editors. Both work well with Next.js.