The Starting Point

We had an ancient (by internet standards) website. It was out of date, hard to update, and didn't reflect our current business model. So we decided to rebuild it all from scratch.

The inputs and constraints:

  • Existing content, images, and video assets
  • 25 years of web development experience
  • Modern AI tools (Claude, ChatGPT, Gemini/Nano Banana 3)
  • A clear vision of what we didn't need
  • Two days to ship - and negative time to build

The result:

  • Clean, fast, custom PHP site
  • 96/100 mobile performance score
  • 99/100 desktop performance score
  • Structured data and SEO fully implemented
  • Zero CMS overhead
  • Total rebuild time: ~16 hours over 2 days

This article is what we lived, learned—and what we think it means for web development in 2025.

The Time Compression Effect - 12 weeks vs 2 days comparison

Decision One: Kill the CMS

We started with the assumption we needed a CMS. We researched options: WordPress, Kirby, Grav, Statamic, Pico... We even began configuring one in hopes it would be the solution.

Then we asked ourselves: What do we actually need?

Our answer:

  • 5 static pages (Home, Services, Insights, About, Contact)
  • A blog with markdown files
  • No user logins, no comments, no e-commerce
  • Simple contact form
  • Ability to update content easily (for technical users)

The realization: We were about to install 100MB of software to serve 5 pages and some text files.

So we killed it. Built a simple PHP router instead: 30 lines of code. Pages are templates. Articles are markdown files. Total codebase: manageable, understandable, fast.

Time saved by avoiding CMS setup, configuration, and learning curve: 4-6 hours.

Decision Two: Template System, Not Framework

No React. No Vue. No build pipeline. We use all those things all the time. But it was overkill here. We only need PHP includes, CSS, and progressive enhancement with vanilla JavaScript.

Why? Because:

  1. Server-rendered HTML is fast. No JavaScript bundle to download before content appears.
  2. Search engines love it. No hydration issues, no client-side rendering delays.
  3. It's simple. Anyone can edit a PHP template file and markdown.
  4. It scales. We can always add more complexity if needed, as needed. AI helps here.

The structure: ``` /index.php # Router (30 lines) /includes/ # Header, footer /pages/ # Page templates /articles/ # Markdown blog posts /assets/ # CSS, JS, images ```

That's it. The entire site.

Stack Complexity Comparison - What we didn't build vs what we built

Decision Three: AI as a Force Multiplier, Not a Replacement

Here's what AI was exceptional at:

  • Code generation: "Create a PHP function to parse markdown frontmatter"
  • Optimization: "Make this CSS mobile-responsive"
  • SEO markup: "Generate Schema.org structured data for this page"
  • Testing and Debugging: "Why is my sitemap returning 404?"
  • Performance: "How do I prevent video download on mobile?"

Here's where 25 years of experience mattered:

  • Architecture decisions: CMS or custom? Framework or templates?
  • Package vetting: AI suggested libraries; we evaluated if we needed them
  • Design sensibility: Layout, typography, color harmony
  • Performance intuition: Knowing which optimizations matter most
  • SEO strategy: What to measure, when to worry, when to ignore

The combination is powerful. AI handled the mechanical work quickly (but not without hiccups). Experience guided the strategic decisions. Together, we moved 10x faster than either alone.

The Iterative Build Process

Traditional waterfall development:

  1. Design mockups
  2. Get approval
  3. Build everything
  4. Test
  5. Fix bugs
  6. Launch

Our process:

  1. Build header (test)
  2. Build hero section (test)
  3. Add video background (test, optimize)
  4. Build services grid (test)
  5. Add parallax section (test, fix reflow)
  6. Optimize images (test score)
  7. Add SEO metadata (validate)
  8. Tune performance (test, iterate)
  9. Launch

Each step took 15-45 minutes. We tested immediately, caught issues early, and never built something we'd have to tear down later.

This is only possible with:

  • Fast local development environment
  • Direct access to browser DevTools
  • AI for rapid code iteration
  • Clear mental model of the end result
The AI Iteration Cycle - Build, Test, Refine in 15-minute loops

The SEO Integration

SEO isn't an afterthought—it's foundational infrastructure. We built in:

Meta tags:

  • Page-specific titles (50-60 characters)
  • Descriptions (150-160 characters)
  • Open Graph tags for social sharing
  • Twitter Cards

Structured Data:

  • Organization schema
  • Article schema for blog posts
  • Breadcrumb navigation (planned)

Technical SEO:

  • XML sitemap (dynamically generated)
  • robots.txt
  • Canonical URLs
  • Mobile-responsive design
  • Fast page load times

Tools we used:

  • Google Search Console
  • Google Tag Manager
  • Schema.org validator
  • Facebook sharing debugger
  • PageSpeed Insights

Time investment: 2 hours to implement, 30 minutes to validate.

The key insight: If you build SEO into your templates from day one, every page gets it for free. Do it as an afterthought, and you're retrofitting 100 pages.

The Performance Tuning Journey

Initial PageSpeed score: 60/100 (mobile)

Issues identified:

  1. Image file sizes too large
  2. Video file: 7 MB
  3. Unused JavaScript: 61 KB
  4. LCP image as CSS background
  5. No image dimensions (causing layout shift)
  6. Render-blocking CSS

The fixes:

Image Optimization

Problem: It's easy and quick to pop a 250kb image file into your site - don't do it Solution: Modern webp format and tools like Acorn can squish 250Kb down to 20Kb Impact: Saved huge data transfer amount, +15 points

Video Optimization

Problem: Video downloaded on mobile even though we didn't need it there. Solution: JavaScript conditional loading—only inject video element on desktop. Impact: Saved 7 MB on mobile, +10 points

JavaScript Cleanup

Problem: Loading animation libraries on pages that didn't use them. Solution: Conditional loading per page, added `defer` attribute. Impact: +5 points

LCP Image Fix

Problem: Largest image was CSS background, discovered late. Solution: Converted to `` tag with `fetchpriority="high"`. Impact: +4 points, 0.8s faster LCP

Image Dimensions

Problem: No width/height on images causing layout shift. Solution: Added dimensions to every image tag. Impact: +3 points, zero layout shift

CSS Optimization

Problem: Full stylesheet blocking render. Solution: Inlined critical CSS, loaded full stylesheet asynchronously. Impact: +3 points

Final score: 96/100 mobile, 99/100 desktop

Time investment: 3 hours of focused optimization work - after the build was done.

The key insight: Performance is about trade-offs. We kept the video on desktop (users expect it), removed it from mobile (they don't need it). We kept rich animations on modern browsers, provided clean fallbacks for older ones.

Performance Score Journey - From 60 to 96 mobile, 70 to 99 desktop

What This Means for Web Development in 2025

The old model:

  • Agencies: $50,000-$150,000 for a custom site
  • Timeline: 1-3 months (used to be even longer!)
  • Deliverables: Often bloated CMS with features you'll never use (looking at you Wordpress)
  • Maintenance: Ongoing updates, security patches (daily on WP), plugin conflicts

The new model:

  • Skilled practitioner + AI: $5,000-$25,000 for a custom site
  • Timeline: 1-4 weeks
  • Deliverables: Purpose-built solution for your actual needs
  • Maintenance: Minimal—no CMS, no plugins, just code

What changed:

  1. AI handles boilerplate. No one should hand-write Schema.org markup anymore.
  2. Templates are faster than frameworks. For most sites, you don't need React.
  3. Simplicity wins. The best code is the code you don't write.
  4. Performance matters. Users and search engines reward fast sites.
  5. Expertise compounds. AI + 25 years of experience = 10x productivity.

The Cost Question

Let's be direct: Website design isn't dead, but the pricing model has fundamentally changed.

What you're paying for in 2025:

  • ❌ Hours spent hand-coding CSS
  • ❌ CMS configuration and customization
  • ❌ Debugging obscure framework issues
  • ✅ Strategic decisions about architecture
  • ✅ Design sensibility and UX expertise
  • ✅ Performance optimization knowledge
  • ✅ SEO and analytics implementation
  • ✅ Knowing what you don't need

A skilled developer with AI can now deliver in 2 days what used to take 2 weeks. The question is: Do you want to pay for the old timeline or the new value?

We believe in charging for value, not hours. This rebuild took us 16 hours. We could have stretched it to 100 hours and built you a CMS with a custom plugin architecture. But you don't need that. Neither do most businesses.

Project Cost Breakdown - $75,000 old model vs $12,000 new model

Lessons for Your Next Project

Before you start:

  1. Define what you actually need, not what you think you should have
  2. Question every dependency. Do you really need that framework?
  3. Start simple. You can always add complexity later.
  4. Plan for performance from day one, not as an afterthought

During development:

  1. Build iteratively. Test every change immediately.
  2. Use AI for mechanics, human judgment for strategy
  3. Optimize as you go. Don't save performance for "later"
  4. Validate SEO immediately. Run the validators after every page.

After launch:

  1. Monitor Core Web Vitals weekly for the first month
  2. Submit sitemap to Google Search Console
  3. Track keyword rankings monthly
  4. Update content regularly (2-4 articles/month)

What's Next

This article is the overview. We're planning deeper dives into:

  • Business needs analysis: How to define what you actually need
  • AI-enabled development: Package selection, vetting, and integration
  • Modern web economics: Why sites don't cost six figures anymore
  • Iterative development: Build-test-refine cycles with AI
  • SEO fundamentals: The tools and tactics that matter in 2025
  • Performance optimization: Common issues and proven fixes

Each article will include real examples, actual code, and specific decisions from this rebuild.

The Bottom Line

We rebuilt our website in two days because:

  1. We knew exactly what we needed (and what we didn't)
  2. We chose simplicity over complexity
  3. We leveraged AI for speed, experience for direction
  4. We built iteratively and tested continuously
  5. We prioritized performance and SEO from the start

The result: A fast, clean, maintainable website that serves our business needs without unnecessary overhead.

The takeaway: Modern web development is about making smart decisions, not writing more code. AI amplifies good judgment—it doesn't replace it.

If you're planning a website project and want to avoid the bloat, the delays, and the six-figure price tag, let's talk about what you actually need.

This article is the first in a series about modern web development. Follow me on LinkedIn for more deep-dive articles on design, development, SEO, and performance optimization.