Skip to content
Technical Guide GEO Migration

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

400-800ms
TTFB
~50-80ms
TTFB (SSG)
Limited
Schema Control
Full
Schema Control

The Problem with No-Code Platforms

IssueWebflow / FramerNext.js
PerformanceLarger bundles, slower TTFBOptimized output, automatic code-splitting
SEO ControlLimited meta tags, basic structured dataFull control over head, Schema.org, sitemap
Geo-OptimizationNot possible nativelyMiddleware for geo-routing, built-in i18n
ScalabilityPlatform limits (CMS items, bandwidth)Unlimited scalability
Vendor Lock-inExport = chaosYour own code, portable anytime
Custom LogicVery limitedFull programming freedom
AI Visibility (AEO)Limited structured data controlFull 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)

MetricWebflow (Standard)Framer (Published)Next.js SSG (Vercel)
Median TTFB400-800ms200-600ms~50-80ms
P95 TTFB800-1,400ms600-1,100ms~80-120ms
First Contentful Paint1.5-2.5s1.2-2.0s~0.5-0.8s
Largest Contentful Paint2.5-4.0s2.0-3.5s~0.8-1.3s
Total Blocking Time200-400ms150-300ms~10-30ms
HTML Size (gzipped)60-100KB80-130KB~8-15KB
JS Bundle Size250-400KB350-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

FeatureWebflowFramerNext.js
Visual EditorYesYesNo (but CMS UI available)
Geo-based RoutingNoNoYes (Edge Middleware)
i18n / MultilingualLimited (Localization available since 2023, but restricted)LimitedYes (built-in via next-intl)
Custom Structured DataBasic (manual per page)No custom markupFull control (JSON-LD per route)
API EndpointsNoNoYes
Edge ComputingNoNoYes
A/B TestingLimitedLimitedYes (Edge Middleware)
Any Headless CMSLimitedLimitedYes (any CMS)
Git-based WorkflowNoNoYes
CI/CD PipelineNoNoYes

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

CrawlerOperatorBehaviorJS Rendering?
GPTBotOpenAICrawls HTML for training data & ChatGPT citations. Respects robots.txt.No. Reads raw HTML only
PerplexityBotPerplexity AIIndexes pages for real-time search answers. Follows links aggressively.Limited. Prefers SSR
Google-ExtendedGoogleFeeds Gemini/AI Overviews. Separate from Googlebot.No. Separate from rendering pipeline
ClaudeBotAnthropicCrawls for Claude's knowledge. Respects robots.txt.No. HTML only
Applebot-ExtendedAppleFeeds 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.

middleware.ts (optional: geo-aware locale detection)
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/ directory structure
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)
    └── ...
keystatic.config.ts
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)

sanity/schemas/blogPost.ts
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

CMSTypePriceBest ForClaude Code Compatible?
KeystaticGit-basedFreeFile-based content, full Git control, zero external dependenciesExcellent (reads/writes files directly)
SanityHeadless APIFree up to 20GBFlexible schemas, real-time editing, media libraryGood (via API)
ContentfulHeadless APIFree up to 25K recordsEnterprise, multi-channel deliveryModerate (API-based)
StrapiSelf-hostedOpen SourceFull control, own infrastructureGood (local API)
Payload CMSSelf-hostedOpen SourceNext.js native, TypeScript-firstGood (local API)
MDX/MarkdownFile-basedFreeBlogs, docs, technical contentExcellent (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

Next.js: Page is fully rendered at crawl time
// 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

Separate meta tags, Schema, OG tags per language
Hreflang tags auto-generated
Shared components, locale-specific content

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

Article Schema Template
{
  "@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.

FAQ Schema Template
{
  "@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

Service Schema Template
{
  "@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.

HowTo Schema Template
{
  "@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

New Blog Post (~2 minutes)

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."
Bulk Content Production

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."
Edit Existing Content
> "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.

CLAUDE.md (example - create this at your repo root)
# 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

TaskWebflow/FramerNext.js + Claude Code
New page2-4 hours10-30 minutes
Design change30-60 minutes5-15 minutes
New languageDays30-60 minutes
SEO optimizationManual per pageAutomated
Structured dataManual/impossibleAutomated

Recommended Tech Stack

Minimum Viable Stack

Framework

Next.js 15 (App Router)

Language

TypeScript

Styling

Tailwind CSS v4

CMS

Keystatic (free, git-based) or MDX

Hosting

Vercel (free tier)

Analytics

Vercel Analytics

Dev Tool

Claude Code

Full Production Stack

Framework

Next.js 15 (App Router)

Language

TypeScript

Styling

Tailwind CSS v4

UI Library

shadcn/ui (Radix Primitives)

CMS

Sanity v3 or Keystatic

Hosting

Vercel Pro

CDN

Vercel Edge Network (automatic)

Analytics

Vercel Analytics + PostHog

Email

Resend

Forms

React Hook Form + Zod Validation

Auth

NextAuth.js / Clerk (if needed)

Monitoring

Sentry

SEO

next-sitemap + JSON-LD (built-in)

i18n

next-intl

Images

next/image + CMS image pipeline

Dev Tool

Claude Code

CI/CD

GitHub -> Vercel (automatic)

Migration Playbook

1

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
2

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)
3

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
4

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.

5

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
6

Phase 6 -- Testing & Launch

next.config.ts
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

Illustrative Example (fictional company)

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

CapabilityWebflow / FramerNext.js + CMS + Claude Code
New blog page30-60 min (manual CMS entry)~10 min (Claude Code + review)
Schema markupManual, error-proneAutomatic, template-based
SSR / SSGBasic (Framer: SSG, Webflow: server-rendered, but no per-route control)Full control -- static, SSR, or ISR per route
AI crawler compatibilityBasic content crawlable, dynamic elements missedComplete (pre-rendered HTML, full Schema)
InternationalizationWebflow Localization (limited), Framer (workaround)Native, clean routing via next-intl
Bulk content productionHours per batch (manual)Minutes per batch (Claude Code + review)
Version controlNone or limitedGit -- every change tracked
CMS cost$20-50/month$0 (git-based) or $0-99/mo (headless)
Vendor lock-inYes (platform-dependent)No (open source, portable)
Geo-based routingNot possibleBuilt-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.

~2 weeks migration 10x content speed $0 CMS cost Full Schema control

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.