I Rebuilt Three Websites with Claude Code (and Canceled Wix + Webflow)

Wix and Webflow are convenient—until you want speed, technical SEO control, analytics hygiene, and fast iteration without paying a premium. I realized I was paying recurring subscriptions for sites I still couldn't evolve as quickly as I wanted.

So I did something about it. Over a few weekends, I rebuilt three production websites using Claude Code, deployed them to Vercel, and wired up the entire Google suite (GA4, Search Console, Tag Manager) from scratch:

• JasonMacht.com — my personal site
• RemailDirect.com — a direct mail automation service
• WhiteSpaceSolutions.ai — my AI automation agency

The result? Better design, faster performance, fully SEO-optimized, and a monthly hosting bill of basically zero. Let me walk you through exactly how I did it.

TL;DR

• What happened: I rebuilt three websites over a few weekends with Claude Code—a handful of focused hours each.
• What changed: Better design, more robust codebase, faster performance, fully SEO-optimized, and connected to GA4, Search Console, and Tag Manager correctly from day one—with an active indexing workflow that gets pages into Google within days, not weeks.
• Why it matters: What used to take an agency or engineers a week can now be done by almost anyone with a clear goal and some imagination—at a fraction of the cost. And unlike most agency handoffs, the SEO loop is actually closed: build, deploy, index, monitor, iterate.

The Before: What Wasn't Working

I had three sites running on hosted site builders—two on Wix, one on Webflow. They worked fine. Sort of. Here's what was bugging me:

SEO felt checkbox-y. Both platforms have SEO settings, but they always felt like I was hoping things were correct rather than knowing. Canonical URLs, JSON-LD schema, sitemap rules—I wanted full control, not a settings panel that may or may not be doing what I think.

Performance was inconsistent. Core Web Vitals would fluctuate. Sometimes a simple layout change would tank my PageSpeed score. I never fully understood why.

Design tweaks took too long. Want to adjust spacing on mobile? That's 20 minutes of clicking through menus. Want to create a new section type? Hope there's a template for that.

The cost kept adding up. Wix and Webflow subscriptions aren't outrageous, but once you add custom domains, remove branding, enable certain features—suddenly you're looking at $30-50/month per site. For what?

The real issue wasn't any single thing. It was that I didn't own the stack. I was renting someone else's tooling and living with their constraints.

What "Better" Meant: My Success Criteria

Before rebuilding, I defined what I actually wanted:

If I couldn't hit all of these, the rebuild wasn't worth it.

Why Claude Code Was the Multiplier

Here's the thing: I didn't hand-code every pixel. I directed outcomes.

The workflow looked like this:

1. I described the change I wanted in plain English
2. I shared screenshots of what I liked (or didn't like)
3. Claude Code translated that into component-level changes
4. I reviewed, shipped, and iterated

This is fundamentally different from using a template. With templates, you're choosing from pre-made options and bending them to fit. With Claude Code, you're getting design + engineering on demand. If I can describe it, I can build it.

One example: I told Claude Code, "Here's a screenshot of my current hero. Make it feel more premium—bigger type, more whitespace, stronger contrast on the CTA button." Within 30 seconds, I had updated code that I could preview locally. Another 30 seconds to deploy. Done.

That feedback loop is the real unlock. You're not blocked by tooling limitations. You're only limited by your ability to describe what you want.

Weekend 1: Rebuilding Site #1

Here's roughly how the first weekend went:

Audit + Plan (30-60 minutes)

Before writing any code, I documented what I had:

• List of all pages
• Content blocks and their hierarchy
• CTAs and forms
• Navigation structure
• URLs I needed to preserve for SEO
• Non-negotiables (contact form, analytics, etc.)

This sounds basic, but skipping this step is how you end up three hours into a rebuild realizing you forgot about your blog's URL structure.

Build the Foundation (1-2 hours)

With Claude Code, I scaffolded the site structure:

• Created the layout components (header, footer, page wrapper)
• Defined the typography scale and spacing rules
• Built reusable section components (hero, features, testimonials, FAQ)
• Set up the color palette and design tokens

The key insight here: build components, not pages. Once I had a solid Hero component, a Card component, and a CTA component, assembling pages became trivial.

SEO Pass (30-60 minutes)

This is where owning the stack really pays off. I implemented:

• Page-specific titles and meta descriptions - Not just "Home | Company Name" everywhere
• Canonical URLs - Explicit canonicals on every page
• XML sitemap - Auto-generated from the page structure
• robots.txt - Clear rules about what to crawl
• JSON-LD structured data - Organization schema, Website schema, Article schema for blog posts
• Open Graph images - Custom OG images that actually look good when shared
• Clean URL structure - Plus a redirect map from the old Wix URLs

On Wix, half of this required plugins or wasn't possible at all. With Claude Code and Next.js, it's just configuration.

Deploy (15-30 minutes)

Pushed to Vercel, connected the domain, validated redirects, and done. The site was live with:

• Automatic HTTPS
• Preview deployments for every branch
• Instant rollbacks if something breaks
• Global CDN distribution

Total active time on Weekend 1: roughly 3-4 hours for a fully functional, SEO-optimized website.

Weekend 2 & 3: Sites #2 and #3 (Why They Went Faster)

The second and third sites took about half the time each. Here's why:

Reuse wins. The design system and components from site #1 carried over almost entirely. Different colors, different content, same building blocks.

Cleaner process. I had a mental checklist now: scaffold → components → SEO → analytics → deploy. No wandering.

Iteration speed. The screenshot → instructions → update → redeploy loop became muscle memory. I could make design changes in under a minute.

By the end of a few weekends, I had three production websites running on a professional stack, with full analytics and SEO infrastructure in place:

• JasonMacht.com — Clean personal brand site with blog
• RemailDirect.com — Product landing page with lead capture
• WhiteSpaceSolutions.ai — Full agency site with service pages, blog, and contact forms

The Technical Stack

I kept things intentionally simple:

Why this stack? It's modern, performant, and Claude Code knows it extremely well. The App Router in Next.js handles routing, SEO metadata, and server-side rendering out of the box. Tailwind makes styling fast and consistent. Vercel makes deployment trivial.

No database. No CMS. No complexity I didn't need. If I want to add a headless CMS later, I can—but for these sites, content-as-code works perfectly.

The SEO Work (In Detail)

Since technical SEO was a primary driver, let me break down exactly what I implemented:

Technical Foundations

✓ Unique title + description per page
✓ Canonical URLs on every page
✓ XML sitemap (auto-generated)
✓ robots.txt with clear crawl rules
✓ Open Graph + Twitter Card meta tags
✓ Clean URL structure
✓ 301 redirects from old Wix/Webflow paths

Structured Data (JSON-LD)

I added schema markup for:

• Organization - Company info, logo, social profiles
• Website - Site name, search potential
• Article - For blog posts with author, date, etc.
• Breadcrumbs - Navigation hierarchy
• FAQ - For FAQ sections (rich results in Google)

On a site builder, this is either impossible or requires a third-party app. With Next.js, it's a component that renders the right <script> tag.

Performance Optimization

• Image optimization - Next.js Image component with automatic WebP conversion
• Lazy loading - Below-fold content loads on demand
• Minimal JavaScript - No bloated plugins
• Edge caching - Vercel serves from the nearest edge location

The result? PageSpeed scores in the 90s across the board. My Wix site was hovering around 65-70.

The Google Suite Setup

Getting analytics right from day one was non-negotiable. Here's how I wired it up:

Google Analytics (GA4)

Installed via Google Tag Manager (not directly). This gives me:

• Clean separation between the site and tracking code
• Easy ability to add/modify tracking without code changes
• Consent mode support for GDPR compliance

Key events I'm tracking:

• Form submissions
• CTA button clicks
• Phone/email taps
• Scroll depth
• Page engagement

Google Tag Manager

I use GTM as the single source of truth for all tracking scripts:

• GA4 configuration
• Conversion tracking
• Any third-party pixels
• Consent management

This matters because when I need to add tracking for something new, I don't touch the codebase. I just add a tag in GTM.

Google Search Console (The Part Most People Skip)

This is where things get interesting—and where most agencies completely drop the ball.

Here's what typically happens: An agency or developer builds you a site, deploys it, and says "you're live!" Maybe they submit a sitemap. Then they move on to the next client. Meanwhile, your pages sit in limbo, waiting for Google to discover them organically. Could be days. Could be weeks. For some pages, Google never bothers.

I took a different approach. Search Console wasn't an afterthought—it was wired into the workflow from day one:

The Setup:

• Domain verification via DNS (more reliable than HTML file method)
• Sitemap submitted immediately after deployment
• URL Inspection API connected for programmatic indexing requests

The Indexing Workflow: Here's the part that closes the loop. Every time I publish a new page or make significant updates, I don't just wait and hope. I actively request indexing through Search Console. The process looks like this:

1. Deploy the new or updated page
2. Run the URL through the URL Inspection tool
3. Request indexing if it's not already in Google's queue
4. Monitor the coverage report for any issues

This sounds manual, but Claude Code can actually automate the entire flow. I have a workflow where publishing a new blog post triggers an indexing request automatically. The page goes live, and within hours—not weeks—it's in Google's index.

Why This Matters: Most SEO "strategies" focus on the front end: keywords, content, on-page optimization. But what good is a perfectly optimized page if Google doesn't know it exists? The indexing step is the missing link between "content published" and "content ranking."

Within a week of launching all three sites, every page was indexed. Not because I got lucky—because I actively pushed them through. The clean technical SEO implementation (proper canonicals, no crawl errors, valid structured data) meant Google had zero friction when processing the requests.

Closing the SEO Loop (What Agencies Miss)

Let me break down why this matters, because it's the difference between "we built you a website" and "we built you a revenue engine."

The typical agency workflow looks like this:

Build → Optimize → Deploy → Done ❌

They hand you the keys and move on. Maybe they check back in a quarter to show you some traffic numbers. But there's a massive gap between "deployed" and "ranking."

My workflow looks like this:

Build → Optimize → Deploy → Index → Monitor → Iterate ✓

That "Index" step is where most people lose months of potential traffic. Here's what I mean:

The Problem with Passive Indexing: Google's crawlers are busy. They have billions of pages to process. Your brand new blog post? It's not a priority. I've seen pages sit in "Discovered - currently not indexed" status for 6+ weeks on sites that don't actively manage their indexing.

The Active Indexing Approach: With Search Console integrated into my workflow, I know within 24-48 hours whether a page is indexed. If it's not, I can diagnose why:

• Is there a crawl error? Fix it.
• Is the page blocked by robots.txt? Update it.
• Is Google seeing duplicate content? Check the canonicals.
• Is the page just in queue? Request indexing directly.

The Compound Effect: When you're publishing content regularly—blog posts, landing pages, case studies—this adds up fast. A site publishing 2-3 pieces per week that waits for organic discovery is leaving 2-3 weeks of potential traffic on the table for each piece. Multiply that across a year and you're talking about months of lost visibility.

By actively managing the indexing pipeline, I'm getting pages into Google's index within days of publishing. That means faster feedback on what's working, faster rankings for time-sensitive content, and faster ROI on the content investment.

The Full Cycle: Here's what the complete workflow actually looks like:

1. Write content using Claude Code with SEO best practices baked in
2. Deploy to Vercel with preview URLs to catch issues before going live
3. Submit to Search Console immediately—don't wait for Google to find it
4. Monitor indexing status and fix any issues within 48 hours
5. Track performance in GA4 and Search Console once indexed
6. Iterate based on what the data shows—then repeat

This isn't rocket science. It's just closing the loop that most people leave open. And it's why my sites were fully indexed and starting to rank within weeks, not months.

Cost Comparison: Before and After

Let's talk numbers:

Before (Wix + Webflow)

• Wix (2 sites): ~$46/month (Business plan each)
• Webflow: ~$29/month (CMS plan)
• Total: ~$75/month or $900/year

Plus occasional contractor costs when I needed something custom.

After (Vercel + Domains)

• Vercel: $0 (Hobby tier covers all three sites easily)
• Domains: ~$12/year each = $36/year
• Total: $3/month or $36/year

Annual savings: $864.

And that's before counting the value of:

• Faster iteration (no more waiting on contractors)
• Full ownership (no platform lock-in)
• Better performance (SEO and user experience)
• Professional codebase (version control, components, TypeScript)

The "Talk to Claude Code" Workflow

This is the real unlock, so let me share some actual prompts I used:

Design refinement:

"Here's a screenshot of my hero section. Make it feel more premium—bigger headline, more whitespace, higher contrast on the CTA button."

Adding features:

"Add a FAQ section below the pricing table. Use an accordion style. Match the existing design system."

Mobile optimization:

"The spacing on mobile feels cramped. Tighten the margins on small screens but keep desktop as-is."

Technical SEO:

"Add JSON-LD Organization schema to the homepage. Include our logo, social profiles, and contact info."

Each of these took under a minute to implement and preview. That's the loop: describe → generate → preview → ship.

Who This Is For (and Who It Isn't)

Let me be honest about who should consider this approach:

Great For:

• Founders and consultants who want full control over their web presence
• Small teams that need to iterate quickly without developer bottlenecks
• Marketers who are comfortable following instructions and giving clear feedback
• Anyone paying for site builders who wants to own their stack instead

Not Ideal For:

• Complex e-commerce with inventory management, payment processing, etc. (possible, but higher complexity)
• Teams requiring WYSIWYG editing - Unless you add a headless CMS, content changes require code updates
• Zero technical comfort - You don't need to be a developer, but you need to be comfortable with a terminal and basic concepts

If you can follow a tutorial and aren't afraid of a command line, you can do this.

A Practical Playbook

If you want to try this yourself, here's the step-by-step:

Step 1: Snapshot Your Current Site

Document everything: pages, content blocks, CTAs, forms, integrations, URL structure. Screenshot every page.

Step 2: Define Your Design System

Before building, decide on: typography scale, spacing values, colors, button styles, card styles. Consistency beats creativity.

Step 3: Build Components, Not Pages

Create reusable building blocks first: Header, Footer, Hero, Features, Testimonials, FAQ, CTA. Then assemble pages from these blocks.

Step 4: Implement SEO + Analytics Early

Don't save this for "later." Set up your meta tags, sitemap, schema, and analytics infrastructure before you have content. It's much easier than retrofitting.

Step 5: Deploy on Vercel

Connect your GitHub repo, point your domain, set up redirects from your old URLs. Vercel handles the rest.

Step 6: Iterate with Screenshots

Treat your site like a living product. Take screenshots, describe what you want changed, update, redeploy. Repeat forever.

Results and Lessons Learned

After running all three sites for a few weeks:

Performance: PageSpeed scores jumped from ~70 to ~95. Core Web Vitals all green across the board.

SEO: All three sites fully indexed within a week. Rich results appearing for FAQ sections.

Cost: Went from $75/month to effectively $3/month.

Iteration speed: Changes that took days now take minutes. I pushed 12 updates in one afternoon last week.

Key Lessons

Clear requirements beat perfect tools. The sites I built aren't objectively "better" than what Wix or Webflow could produce. But I know exactly what I have, and I can change anything instantly.

Shipping small changes quickly compounds. Instead of "version 2" redesigns, I make small improvements constantly. The cumulative effect is massive.

Ownership of the stack pays off long-term. No more worrying about price increases, feature deprecation, or platform limitations. The code is mine, hosted wherever I want.

The Bottom Line

Websites are no longer "big projects" if you can direct an AI coding agent effectively.

I'm not suggesting everyone should cancel their Wix subscription tomorrow. But if you've ever felt limited by your site builder—frustrated by performance issues, constrained by design options, or annoyed by recurring costs for basic features—know that there's another path.

A few weekends. Three websites. Full ownership. Better results.

If you're interested in making the switch but want some guidance, reach out. I help businesses audit their current sites, plan migrations, and implement the technical SEO and analytics infrastructure that actually moves the needle.

---

Frequently Asked Questions

Do I need to know how to code?

Not really. You need to be comfortable with a terminal and willing to follow instructions. Claude Code writes the code—you describe what you want and review the output. If you can install software and follow a tutorial, you can do this.

How long does the migration actually take?

For a typical 5-10 page marketing site, expect 4-8 hours of focused work spread across a weekend or two. Complex sites with blogs, multiple content types, or custom functionality will take longer.

What about content updates after launch?

You have two options: edit the content directly in the code (it's just text in files) or add a headless CMS like Sanity or Contentful. For most small sites, editing files directly is faster than logging into a CMS.

Will I lose SEO rankings during the migration?

Not if you do it right. The key is implementing proper 301 redirects from your old URLs to your new URLs. I also recommend keeping your URL structure as similar as possible to minimize redirect chains.

What if something breaks?

Vercel keeps every deployment, so you can roll back to any previous version in about 10 seconds. Version control means you can see exactly what changed and when. It's actually safer than site builders where "undo" is limited.

Can I still use forms and contact features?

Absolutely. I use services like Formspree or build simple API endpoints for form handling. It's not harder than setting up a form in Wix—just different.

How do you handle getting pages indexed quickly?

This is actually one of the biggest advantages of owning your stack. I have Search Console connected with API access, so I can programmatically request indexing for new pages. When I publish a new blog post or landing page, I don't wait for Google to discover it—I submit it directly. Combined with a clean technical SEO setup (valid sitemaps, no crawl errors, proper canonicals), pages typically get indexed within 24-72 hours instead of weeks. Most agencies skip this step entirely, which is why you see sites with great content sitting in "Discovered - currently not indexed" limbo for months.