From Idea to Live Site: My Repeatable 48-Hour Website Framework

Speed in software development is almost always a byproduct of decisions already made, not effort applied in the moment.

When TheWestNepal.live went from concept to live production site in 48 hours, it was not because I worked harder than usual. It was because I had already decided: the stack (Next.js + Supabase + Vercel), the structure (app router, server components, ISR), the auth approach, the SEO layer, and the deployment target. There were no architecture decisions to make during the build. Only building.

Here is the framework — six stages, in sequence, with no skipping.

Stage 1: Schema First (2–4 hours)

Before any Next.js code, I open the Supabase SQL editor and write the schema.

The schema defines what the site can store and display. Every page is, ultimately, a query against some table. Defining the tables first means every subsequent decision — what to build, what to display, what to admin — has a clear answer.

For TheWestNepal.live, the schema took 90 minutes: articles, categories, authors, tags. Simple fields, correct types, foreign keys, indexes on slugs and published_at.

A schema that takes 2 hours to write will take 2 days to add to mid-build if you skip it.

Stage 2: Next.js Scaffold (1–2 hours)

npx create-next-app with TypeScript and Tailwind, then immediately wire the Supabase client in lib/supabase.ts and create the core layout in app/layout.tsx.

I do not install additional packages at this stage. No UI component library, no animation library, no date library. Those come later, when I know I need them. The scaffold is: framework, database client, core layout, global CSS.

Stage 3: Backend + API Layer (4–8 hours)

Server components fetch data directly from Supabase — no intermediate API layer for reads. The patterns are consistent: every data-fetching function lives in lib/ and returns typed data.

// lib/articles.ts
export async function getPublishedArticles(): Promise<Article[]> {
  const { data } = await supabase
    .from('articles')
    .select('*')
    .eq('published', true)
    .order('published_at', { ascending: false });
  return data ?? [];
}

Write operations (contact form, newsletter signup) get API routes in app/api/.

The admin panel gets built in parallel with the public pages — they share the same database, so building one informs the other.

Stage 4: Content (2–4 hours)

For TheWestNepal.live, content was the exported WordPress data, transformed and loaded into Supabase. For new sites, content is either seeded placeholder data or real content written in the CMS.

The key principle: no deploy until the site has real content. Deploying an empty site to verify the structure is fine. Launching an empty site as if it were the real thing is not.

Stage 5: SEO (2–3 hours)

This is the stage most developers skip or defer. Do not.

The SEO layer is:

• —sitemap.ts generating from Supabase (every published article, automatically)
• —robots.ts with correct allow/disallow rules
• —Schema markup per content type (BlogPosting, BreadcrumbList)
• —Per-page metadata from database records (generateMetadata in Next.js)
• —Open Graph tags for social sharing

This layer takes 2–3 hours to build once and costs nothing to maintain. Deferring it costs you weeks of indexing lag.

Stage 6: Deploy (30 minutes)

git push to GitHub. Vercel detects the push, builds, deploys. Set the custom domain in Vercel's dashboard. Add the domain's DNS records (CNAME or A record) in Namecheap. Wait 5–30 minutes for DNS propagation.

The site is live.

Why the Sequence Matters

The stages run in dependency order. Schema before scaffold because the scaffold depends on knowing what data exists. Backend before content because you need somewhere to put the content. SEO before deploy because you want to be indexable from day one.

Violating the sequence does not make individual stages faster — it makes later stages harder. A scaffold without a schema generates placeholder queries. Content without a backend has nowhere to live. A deploy without SEO is invisible.

The 48-hour number is real for TheWestNepal.live because I had run this sequence before and the decisions were already made. For a developer running the sequence for the first time, 5–7 days is more realistic. The second time is 3 days. The third time is 48 hours.

---

Resources

• —Next.js create-next-app — the scaffold command; use --typescript --tailwind --app for this stack
• —Supabase quickstart for Next.js — the fastest path from create-next-app to a working Supabase connection
• —Google Search Console — submit your sitemap here immediately after launch; do not wait

Related Posts

• —The GitHub Student Pack Stack: Free Domain, Free Hosting, Real Production Sites — the free infrastructure this framework runs on
• —Case Study: Turning a WordPress News Site Into a Modern Platform in 48 Hours — TheWestNepal.live running this exact framework in the real 48-hour window
• —Auto Sitemap, Schema, and Robots.txt: The 3 Files Most Developers Forget — Stage 5 (SEO) of the framework explained in full detail

---

Want this framework applied to your project? I build full-stack sites in days using exactly this sequence — schema-first, SEO-included, production-ready from day one. See my services or get in touch.