The 30-Day MVP: A Project Manager’s Roadmap to Launching Faster

[Week 1: Foundations] -------------> [Week 2: Feature Build] ----------> [Week 3: Integrations] --------------> [Week 4: Launch]
  * Scoping & MoSCoW scoping          * Core workflow feature logic        * Setup Better Auth login           * Intensive QA & testing
  * Setup Drizzle DB schema           * UI/UX interactive workspace        * Stripe Embedded Checkout          * SEO metadata, robots & sitemap
  * Install Next.js boilerplate       * API state handling pipelines       * Transactional email alerts        * Neon serverless deploy

// src/db/schema.ts
import { pgTable, text, timestamp, boolean, uuid } from "drizzle-orm/pg-core";
import { relations, sql } from "drizzle-orm";

// Chronologically sortable UUIDv7 helper for modern PostgreSQL
export const uuidv7Key = uuid("id")
 .primaryKey()
 .$defaultFn(() => sql`gen_random_uuid()`); // Or a custom uuidv7() function if supported natively

export const users = pgTable("user", {
  id: text("id").primaryKey(), // Better Auth standard format
  name: text("name").notNull(),
  email: text("email").notNull().unique(),
  emailVerified: boolean("email_verified").notNull().default(false),
  image: text("image"),
  createdAt: timestamp("created_at").notNull().defaultNow(),
  updatedAt: timestamp("updated_at").notNull().defaultNow(),
});

export const sessions = pgTable("session", {
  id: text("id").primaryKey(),
  expiresAt: timestamp("expires_at").notNull(),
  token: text("token").notNull().unique(),
  createdAt: timestamp("created_at").notNull().defaultNow(),
  updatedAt: timestamp("updated_at").notNull().defaultNow(),
  ipAddress: text("ip_address"),
  userAgent: text("user_agent"),
  userId: text("user_id")
   .notNull()
   .references(() => users.id, { onDelete: "cascade" }),
});

export const organizations = pgTable("organization", {
  id: text("id").primaryKey(),
  name: text("name").notNull(),
  slug: text("slug").notNull().unique(),
  logo: text("logo"),
  stripeCustomerId: text("stripe_customer_id"),
  subscriptionStatus: text("subscription_status"),
  createdAt: timestamp("created_at").notNull().defaultNow(),
  updatedAt: timestamp("updated_at").notNull().defaultNow(),
});

export const members = pgTable("member", {
  id: text("id").primaryKey(),
  organizationId: text("organization_id")
   .notNull()
   .references(() => organizations.id, { onDelete: "cascade" }),
  userId: text("user_id")
   .notNull()
   .references(() => users.id, { onDelete: "cascade" }),
  role: text("role").notNull().default("member"), // 'admin' | 'member'
  createdAt: timestamp("created_at").notNull().defaultNow(),
  updatedAt: timestamp("updated_at").notNull().defaultNow(),
});

// Relational mappings for clean type inferencing
export const usersRelations = relations(users, ({ many }) => ({
  sessions: many(sessions),
  members: many(members),
}));

export const organizationsRelations = relations(organizations, ({ many }) => ({
  members: many(members),
}));

export const membersRelations = relations(members, ({ one }) => ({
  organization: one(organizations, {
    fields: [members.organizationId],
    references: [organizations.id],
  }),
  user: one(users, {
    fields: [members.userId],
    references: [users.id],
  }),
}));

// middleware.ts
import { NextRequest, NextResponse } from "next/server";
import { headers } from "next/headers";
import { auth } from "@/lib/auth"; // Better Auth instance

export async function middleware(request: NextRequest) {
  const { pathname } = request.nextUrl;

  const isProtectedRoute = pathname.startsWith("/dashboard") || pathname.startsWith("/billing");
  const isAuthPage = pathname.startsWith("/sign-in") || pathname.startsWith("/sign-up");

  if (!isProtectedRoute && !isAuthPage) {
    return NextResponse.next();
  }

  // Perform full database validation of the session directly at the network boundary
  const session = await auth.api.getSession({
    headers: await headers(),
  });

  if (isProtectedRoute && !session) {
    const loginUrl = new URL("/sign-in", request.url);
    loginUrl.searchParams.set("callbackUrl", pathname);
    return NextResponse.redirect(loginUrl);
  }

  if (isAuthPage && session) {
    return NextResponse.redirect(new URL("/dashboard", request.url));
  }

  return NextResponse.next();
}

export const config = {
  runtime: "nodejs", // Activates the Node.js runtime environment for middleware
  matcher: [
    "/dashboard/:path*",
    "/billing/:path*",
    "/sign-in",
    "/sign-up"
  ],
};

+------------------+                   +------------------------+                   +--------------+
|   User Browser   |                   |  Next.js Server Action |                   |  Stripe API  |
+--------+---------+                   +-----------+------------+                   +------+-------+
         |                                         |                                       |
         | ---- Clicking Checkout Button --------> |                                       |
         |                                         | ---- Create Checkout Session -------> |
         |                                         | <--- Return clientSecret ------------ |
         | <--- Mount Embedded IFrame ------------ |                                       |
         |                                                                                 |
         | ========================= User submits payment ================================ |
         |                                                                                 |
         | ------------------------- Post Secure Card Token -----------------------------> |
         |                                                                                 |
         |                                         | <==== Asynchronous HTTP Webhook ===== |
         |                                         |       (checkout.session.completed)    |
         |                                         |                                       |
         |                                         | ---- Update localized database ---->  |
         | <--- Success Redirect and Return ------ |                                       |

// src/app/actions/stripe.ts
"use server";

import { stripe } from "@/lib/stripe";
import { db } from "@/db";
import { organizations } from "@/db/schema";
import { eq } from "drizzle-orm";
import { headers } from "next/headers";

export async function createCheckoutSession(organizationId: string, priceId: string) {
  const origin = (await headers()).get("origin");
  if (!origin) {
    throw new Error("Could not resolve application request origin.");
  }

  const org = await db.query.organizations.findFirst({
    where: eq(organizations.id, organizationId),
  });

  if (!org) {
    throw new Error("Target organization workspace was not found.");
  }

  let stripeCustomerId = org.stripeCustomerId;

  if (!stripeCustomerId) {
    const customer = await stripe.customers.create({
      name: org.name,
      metadata: { organizationId: org.id },
    });
    stripeCustomerId = customer.id;

    await db
     .update(organizations)
     .set({ stripeCustomerId })
     .where(eq(organizations.id, org.id));
  }

  // Create highly optimized Embedded Checkout Session
  const session = await stripe.checkout.sessions.create({
    customer: stripeCustomerId,
    ui_mode: "embedded",
    line_items: [{ price: priceId, quantity: 1 }],
    mode: "subscription",
    return_url: `${origin}/dashboard/billing/return?session_id={CHECKOUT_SESSION_ID}`,
    automatic_tax: { enabled: true }, // Natively handles dynamic global sales tax
    tax_id_collection: { enabled: true }, // Captures tax IDs for B2B billing
  });

  return { clientSecret: session.client_secret };
}