DEV Community: 럭키리치

How I ship a production website in 7 days with one HTML file and a Python SEO generator

럭키리치 — Sat, 18 Apr 2026 15:15:36 +0000

I run a one-person web agency called the vibe company that ships real client sites in 7 days. Live: zamhwa-studio.netlify.app. This post is the stack and the actual code that makes the 7-day promise not a lie.

TL;DR stack

1 HTML file per client (yes, still in 2026)
Netlify for hosting, HTTPS, forms, analytics
Python 3 script that generates topical SEO cluster pages
Playwright for cross-viewport QA screenshots
Claude for first drafts (I rewrite ~60% of the output)

Zero frameworks. Zero build step beyond netlify deploy. Zero CMS.

Why no framework

I'm not anti-framework. I'm anti-framework-for-brochure-sites. Ninety percent of small business sites are:

Hero
Services
Portfolio
Pricing
Contact form
Footer

A single HTML file with Tailwind utility classes compiled in via CDN ships in 3 days. The same site in Next.js ships in 6 and costs me Vercel time I can't bill for.

The rule I use: if the client updates content less than once a month, they don't need a CMS.

The Python SEO generator (the actual code)

This is the piece that took me from "pretty site" to "site that Google can place in context." The idea: generate a small cluster of topically related static pages so each page's internal links reinforce the main site's authority.

# seo_gen.py — minimal version, ~80 lines
from pathlib import Path
import json, html

TEMPLATE = """<!doctype html>
<html lang="{lang}">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width,initial-scale=1">
  <title>{title}</title>
  <meta name="description" content="{description}">
  <link rel="canonical" href="{canonical}">
  <script type="application/ld+json">{schema}</script>
  <link rel="stylesheet" href="/style.css">
</head>
<body>
  {header}
  <main>
    <h1>{h1}</h1>
    {body}
    <aside class="related">
      <h2>Related</h2>
      <ul>{related_links}</ul>
    </aside>
  </main>
  {footer}
</body>
</html>
"""

def render_page(page, all_pages, header, footer):
    related = [p for p in all_pages if p["slug"] in page["internal_links"]]
    related_links = "".join(
        f'<li><a href="/{p["slug"]}">{html.escape(p["title"])}</a></li>'
        for p in related
    )
    schema = json.dumps({
        "@context": "https://schema.org",
        "@type": "Article",
        "headline": page["h1"],
        "description": page["description"],
    })
    return TEMPLATE.format(
        lang=page.get("lang", "ko"),
        title=page["title"],
        description=page["description"],
        canonical=f'https://zamhwa-studio.netlify.app/{page["slug"]}',
        schema=schema,
        header=header,
        h1=page["h1"],
        body=page["body_html"],
        related_links=related_links,
        footer=footer,
    )

def build(pages_json="pages.json", out_dir="dist"):
    pages = json.loads(Path(pages_json).read_text(encoding="utf-8"))
    header = Path("partials/header.html").read_text(encoding="utf-8")
    footer = Path("partials/footer.html").read_text(encoding="utf-8")
    out = Path(out_dir)
    out.mkdir(exist_ok=True)
    sitemap = ['<?xml version="1.0" encoding="UTF-8"?>',
               '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">']
    for page in pages:
        (out / f'{page["slug"]}.html').write_text(
            render_page(page, pages, header, footer), encoding="utf-8"
        )
        sitemap.append(
            f'<url><loc>https://zamhwa-studio.netlify.app/{page["slug"]}</loc></url>'
        )
    sitemap.append("</urlset>")
    (out / "sitemap.xml").write_text("\n".join(sitemap), encoding="utf-8")

if __name__ == "__main__":
    build()

pages.json looks like this:

[
  {
    "slug": "guide/cost-2026",
    "title": "홈페이지 제작 비용 2026 | the vibe company",
    "h1": "2026 홈페이지 제작 비용 완전 가이드",
    "description": "실제 견적서와 패키지별 단가.",
    "body_html": "<p>...</p>",
    "internal_links": ["guide/domain", "guide/seo-checklist"]
  }
]

Run python seo_gen.py → dist/ has 8 HTML files plus sitemap.xml → netlify deploy --prod --dir=dist. Done.

The live cluster is here if you want to see the output:

/guide/cost-2026 — cost breakdown
/guide/domain — domain decision tree
/guide/seo-checklist — the checklist I actually use

The Playwright QA runner

I never deploy without running this:

// qa.js
const { chromium } = require('playwright');

const viewports = [
  { name: 'mobile', width: 375, height: 812 },
  { name: 'tablet', width: 768, height: 1024 },
  { name: 'desktop', width: 1440, height: 900 },
];

const urls = [
  'https://zamhwa-studio.netlify.app/',
  'https://zamhwa-studio.netlify.app/guide/cost-2026',
  'https://zamhwa-studio.netlify.app/industries/cafe',
];

(async () => {
  const browser = await chromium.launch();
  for (const vp of viewports) {
    const ctx = await browser.newContext({ viewport: vp });
    for (const url of urls) {
      const page = await ctx.newPage();
      await page.goto(url, { waitUntil: 'networkidle' });
      const slug = url.replace(/[^a-z0-9]/gi, '_');
      await page.screenshot({ path: `shots/${vp.name}_${slug}.png`, fullPage: true });
      await page.close();
    }
    await ctx.close();
  }
  await browser.close();
})();

Before every client call I flip through the shots. In the last month this has caught iOS Safari button cutoff, a mobile-only stacked nav regression, and one CDN image cache that was serving a blurry variant.

Where Claude actually helps (and doesn't)

Helps a lot:

First draft of copy in both EN and KR
Writing Python glue scripts like the one above
Debugging CSS weirdness at 2am
Explaining error messages from Netlify build logs

Does not help:

Deciding the pricing tiers
Choosing what goes above the fold for a specific client
Anything involving the client's actual business

The honest version: it's a human-run shop where the human got faster. That's enough.

What this site ranks for (after 4 weeks)

"홈페이지 제작 비용" (home-page production cost, Korean) — page 2 on Naver
"카페 홈페이지 제작" — page 1 on Naver, position 6
"netlify korean agency" — position 2 on Google

Not massive, but the trajectory is up, and every cluster page adds link equity to the root.

If you want to poke at the live site

Main: zamhwa-studio.netlify.app
Pricing guide with real numbers: cost-2026

Happy to answer stack questions in the comments. Especially interested in any Naver SEO specifics that aren't obvious from the Google side — that's still the part I'm learning in public.

Shipping a production agency site in 7 days with Claude + Netlify (with code)

럭키리치 — Sat, 18 Apr 2026 15:13:53 +0000

I just finished a one-person sprint: build, deploy, and market a real web agency business end-to-end in a week. Live at zamhwa-studio.netlify.app.

No framework. No CMS. No backend. Just HTML, Netlify, and aggressive programmatic SEO.

Here's the code.

The architecture

/
├── index.html            # Single-file landing (~1100 lines)
├── netlify.toml
├── robots.txt
├── sitemap.xml
├── _redirects
├── thumbs/*.jpg          # Real screenshots of portfolio sites
├── guide/
│   ├── cost-2026/index.html
│   ├── domain/index.html
│   └── seo-checklist/index.html
├── industries/
│   ├── cafe/index.html
│   ├── clinic/index.html
│   ├── shop/index.html
│   └── startup/index.html
└── vs/
    └── imweb/index.html

That's it. No React, no Vite, no build step. It's 2026 and for a landing page that needs to rank, plain HTML beats everything.

Why no framework?

Three reasons.

First, Time-to-First-Byte. Netlify serves static HTML from edge in ~30ms. A Next.js app on Vercel with SSR on the same page was 180ms. For a Korean audience on 4G mobile, that's the difference between a 70 LCP and a 95.

Second, Google understands it instantly. No hydration mismatch, no JS-rendered content to wait on, no framework-specific canonicalization bugs.

Third, I can iterate at the speed of thought. Edit a line, git push, live in 30 seconds. I shipped 23 deploys in 7 days.

The SEO generator (Python)

HEAD_TMPL = """<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8" />
<title>{title}</title>
<link rel="canonical" href="https://zamhwa-studio.netlify.app/{slug}" />
<script type="application/ld+json">
{{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "{title}",
  "author": {{ "@type": "Organization", "name": "the vibe company" }}
}}
</script>
..."""

for slug, meta in pages.items():
    html = HEAD_TMPL.format(**meta, slug=slug) + BODIES[slug] + FOOTER_TMPL
    write(f"{slug}/index.html", html)

Eight pages, 2000+ words each, full structured data, rendered in 90 seconds. Every page gets BreadcrumbList + Article JSON-LD, canonical, OG, and inline CTAs.

Netlify Forms — the simplest order intake possible

<form name="contact" method="POST" data-netlify="true" netlify-honeypot="bot-field">
  <input type="hidden" name="form-name" value="contact" />
  <input name="name" required />
  <input name="contact" required placeholder="email or phone" />
  <select name="package">
    <option>Starter</option><option>Business</option><option>Premium</option>
  </select>
  <textarea name="message"></textarea>
  <button type="submit">Send</button>
</form>

Netlify detects data-netlify="true" at build time, routes submissions to its form service, and emails me on every submission. Zero backend code. Honeypot blocks 99% of spam.

Screenshots with Playwright (not thum.io)

Third-party screenshot services fail a lot. CORS, rate limits, stale images. For production, just capture them yourself:

import { chromium } from 'playwright-core';

const browser = await chromium.launch({ args: ['--no-sandbox'] });
const ctx = await browser.newContext({ viewport: { width: 1400, height: 900 } });
const page = await ctx.newPage();

for (const site of SITES) {
  await page.goto(site.url, { waitUntil: 'networkidle', timeout: 30000 });
  await page.waitForTimeout(2000);
  await page.screenshot({ path: `thumbs/${site.slug}.jpg`, type: 'jpeg', quality: 85 });
}

await browser.close();

I serve these from the same domain, so no CORS, no hotlink block, no weird CDN costs.

robots.txt — block what doesn't help you

User-agent: *
Allow: /

User-agent: Googlebot
Allow: /
User-agent: Yeti
Allow: /
User-agent: Bingbot
Allow: /

User-agent: SemrushBot
Disallow: /
User-agent: AhrefsBot
Disallow: /
User-agent: MJ12bot
Disallow: /

Sitemap: https://zamhwa-studio.netlify.app/sitemap.xml

Semrush/Ahrefs bots hit your site 50–200 times a day. They give you zero traffic. Block them. Your Googlebot crawl budget goes up.

Results (Day 7)

9 URLs indexed in Google Search Console
Lighthouse Performance: 98 / Accessibility: 100 / SEO: 100
First order inquiry: 3 leads in the first 48 hours from cold traffic
Total infra cost: $0 (Netlify free tier) + $22 for the .kr domain

The full code

All of it is public and you can read it by viewing source on any page at zamhwa-studio.netlify.app. The SEO checklist guide walks through every tactic I used.

If you're building something similar and want to compare notes, my inbox is open.

I built a 1-person web agency in 7 days using Claude Code + Netlify. Full stack + pricing breakdown.

럭키리치 — Sat, 18 Apr 2026 15:00:11 +0000

TL;DR

I'm a performance marketer (8 years) who got tired of watching agencies charge clients $20k-50k for websites that take 3 months and don't convert. So I built my own 1-person agency, the vibe company, with a radically different stack:

Stack: Single-file HTML + Tailwind, Netlify hosting, Python SEO page generator, Playwright screenshots
Price: $260 - $1,300 USD (1/3 of agency pricing)
Timeline: 5-21 days (1/3 of agency speed)
Monthly cost to client: $0 (Netlify free tier + $12/year domain)
Live portfolio: 6 sites shipped and running

Site: zamhwa-studio.netlify.app

The real problem with web agencies in 2026

I ran paid ads for 8 years. I've seen hundreds of landing pages fail. Here's the pattern:

Agency charges $30k for a "brand refresh"
Takes 3 months
Delivers a pretty Figma export that doesn't convert
Charges $300/month retainer forever

The designers don't understand ad funnels. The developers don't know CRO. The project managers extend timelines to justify fees.

Meanwhile, the actual work — designing a page that converts cold traffic — is something a single person with the right tools can do in a week.

The stack that made this work

├── Design:    Figma + v0 + AI-generated Tailwind
├── Dev:       Claude Code + Cursor
├── Hosting:   Netlify (free tier, auto SSL, CDN)
├── SEO:       Python generator → 1,200+ location pages
├── QA:        Playwright screenshots across viewports
└── Payment:   Toss Payments (Korea)

No CMS. No backend unless client explicitly needs one. No subscription fees. Every site is a single HTML file that loads in under 800ms.

Pricing (first 10 clients, 30% off)

Package	Price	Pages	Timeline
Starter	$260	1-page landing	5-7 days
Business	$530	Up to 5 pages	10-14 days
Premium	$1,330	Unlimited + AI + CMS + payments	14-21 days

The full pricing breakdown I published: 2026 web agency cost guide

Live portfolio (all in production)

NEMORIZZ — photobooth rental e-commerce
Drain Korea — 24hr emergency plumbing service
Stareum — celebrity booking + equipment rental platform (1,200+ SEO pages)
Isabella Blind — smart home AIoT brand site
SNAPOZ — premium photobooth landing
대한 건강사주 — health diagnosis SaaS

The SEO trick: programmatic location pages

For Stareum (the celebrity booking platform), I generated 1,219 location-specific landing pages programmatically. Python reads a CSV of Korean administrative districts, fills a Jinja2 template with district name + nearby popular artists + booking cost data. Each page gets unique metadata, schema.org JSON-LD, and internal links.

Result: 1,219 pages indexed by Google in 4 weeks. Target keyword rankings jumped from page 10 to page 1 for a dozen [city + celebrity booking] queries.

The full SEO checklist I used.

Why $0/month hosting is the real unlock

Most agencies charge $300/month "maintenance" because they built the site on WordPress + a VPS. That's $3,600/year the client bleeds forever.

Netlify free tier gives you:

100GB bandwidth/month
Free SSL + CDN (Cloudflare-grade)
Deploy previews + rollback
Build minutes sufficient for 5+ sites

The only recurring cost to the client: a domain ($12/year). That's the business model small shops have been waiting for.

Domain purchase — where I send clients

Short guide: domain buying guide

.com → Cloudflare Registrar (no markup, $9.15/year)
.co.kr → Gabia (Korean local registrar)

What I learned

Marketing-first design beats aesthetic design. Every one of my sites started from ad funnel logic, not Dribbble inspiration.
SEO is a compounding asset. The 1,219 pages I generated once now drive 400+ organic visits/day with zero ad spend.
Speed is a moat. Agencies can't compete when you deliver in 7 days because their process overhead is 3 weeks minimum.

Open invitation

If you're building something similar — or you need a site built fast and cheap — the site is live:

Main: zamhwa-studio.netlify.app
Pricing: zamhwa-studio.netlify.app/#pricing
Cost guide: zamhwa-studio.netlify.app/guide/cost-2026
SEO checklist: zamhwa-studio.netlify.app/guide/seo-checklist

Happy to answer questions in comments about the stack, pricing, or SEO generator code.