The waitlist is often the first real interaction a user has with a product.

For many startups, that first interaction is handled by a third-party tool that adds extra scripts, slows down the page, and limits control over user data. I wanted to build a better version: a fast, lightweight, and fully owned waitlist system that feels native to the product itself.

You can view the live project here: waitlist.saifulalom.com
Source code: GitHub

Why I Built It

This project was not just about creating a signup form. It was about answering a practical product question:

How can early-stage startups capture signups as quickly and simply as possible?

For a landing page, performance matters directly because slower pages can hurt conversions. I wanted to build something that loads fast, stores data safely, and stays simple to maintain.

What It Solves

Many waitlist tools depend on external services that introduce tradeoffs.

They can:

• slow down the page with extra scripts
• store user data in third-party systems
• limit design and workflow control

This project solves that by keeping the waitlist inside the product stack. That gives the team:

• full control over user data
• faster page loads
• simpler deployment
• easier customization

What It Includes

The waitlist includes:

• a landing page with signup form
• email capture flow
• fast server-side handling
• database-backed subscription storage
• type-safe schema and query handling
• a simple, focused user experience

Stack Choice

I built this project with a lightweight edge-native setup:

• Astro for fast page rendering
• React for the interactive form
• Cloudflare D1 for SQL storage
• Drizzle ORM for type-safe queries
• TypeScript for end-to-end reliability

This stack keeps the project simple while still feeling production-ready.

Why Astro

I chose Astro because this project is content-first and performance-sensitive.

Astro works well here because:

• it ships very little JavaScript by default
• it keeps the page fast
• it only hydrates the parts that need interactivity
• it supports flexible deployment

For a waitlist page, that is a strong fit.

Why Not a Typical React App

A traditional React app can work, but it often sends more JavaScript than this kind of page needs.

For a waitlist, too much client-side code can:

• slow the first load
• increase hydration time
• make the page feel heavier than necessary

Astro solves that by keeping most of the page static and only hydrating the form.

Edge Deployment

This project is designed for the edge, which means it runs close to users instead of depending on a distant centralized server.

That helps with:

• faster response times
• better global performance
• simpler scaling for early-stage products

For a startup landing page, that can make a noticeable difference.

Database Design

The project uses Cloudflare D1 to store subscription data in a simple SQL format.

Drizzle ORM helps keep the database layer type-safe, which makes the project easier to maintain and less error-prone.

This approach gives the project:

• structured storage
• clear schema management
• safer updates
• good compatibility with edge runtimes

Type Safety

Type safety was an important part of the build.

Using TypeScript with a typed database layer means errors are caught during development instead of after deployment. That makes the project more reliable and easier to evolve later.

If the schema changes, the app has to stay in sync, which reduces runtime surprises.

Performance Goals

The goal was not to build a huge system. The goal was to build a waitlist that feels fast, clean, and trustworthy.

The project focuses on:

• quick page load
• reliable signup capture
• low overhead
• simple infrastructure
• full ownership of data

Lessons Learned

This project reinforced an important idea: great products often start with simple foundations.

Instead of adding complexity too early, this waitlist focuses on:

• speed
• ownership
• maintainability
• clean user experience

That makes it useful as both a product experiment and a portfolio case study.

Why This Matters

This project shows that I can build:

• landing pages
• waitlist systems
• lightweight signup flows
• edge-native web apps
• database-backed product features

It also shows how I think about real product constraints like performance, data ownership, and simplicity.

Final Thoughts

This waitlist is a small project, but it represents a bigger approach: build the smallest useful version, keep it fast, and make it easy to own.

That mindset is useful for startups, freelance work, and product engineering alike.