Live · Actively maintained

Building a better NYC happy hour directory

My friends and I kept running into the same problem: finding a decent place for cheap food and drinks meant digging through old Reddit threads and half-maintained spreadsheets. So I built the directory I wanted to use myself.

Visit the live site →
1,000+ Confirmed happy hours
2,300+ Venues in the directory
4,000+ Visitors since launch
5 Boroughs covered
512 Application tests
Live Launched July 2026, still maintained

Why I built it

The options I found usually had one of two problems: good information with little coverage, or lots of venues with data that was hard to search and harder to keep current. Neither helps when four people are standing on a corner trying to decide where to go.

So the project came down to three problems: getting the data right, making it easy to search, and keeping it from going stale.

The product

NYCHappyHours.org covers 1,000+ confirmed happy hours in a directory of 2,300+ venues across all five boroughs. It has list and map views, live and upcoming status, last-call timing, location-aware sorting, saved spots, and per-venue deal details. None of it was designed once and shipped. It came out of dozens of iterations, with real people using the site at every step.

The NYC Happy Hours homepage on desktop: the bar-lit banner, a search field, and filters showing 479 happy hours running in Manhattan.
The homepage on a weekday evening: search first, then the filters that matter at 6 p.m., with a live count of what’s running.
The homepage on a phone: search, filters, the live count, and the first venues. The list view in the light theme, with last-call countdowns and deal prices. The same list in the dark theme.
On a phone, where it’s meant to be used: the opening screen, then the list in both themes, sorted by ending soonest so last call leads each card.

The data problem

There was never one clean source. The data came from years-old Reddit threads by people who’d tried this before, blog roundups, news posts, and the spots my friends and I had been going to for years. The hard part was reconciling all of it into one structured dataset a site could run on.

My first instinct was a Google Sheet: anyone can edit it, and there’s no infrastructure. But a happy hour can have different hours, food specials, and drink specials for every day of the week, across thousands of venues. Modeling that directly in a spreadsheet would have meant roughly 50 columns per venue. Instead I used a handful of columns holding a tightly structured schedule string, parsed later in PostgreSQL. The cost was fragility: if I added a venue by hand, one bad character could stop the schedule from parsing. The admin system below is what fixed that.

Building it to outlast the launch

A directory like this usually dies the same way: someone builds it, stops maintaining it, and it goes stale. I didn’t want to build version three of that failure, so the system for keeping it current went in before I called it an MVP. Two simple forms collect corrections and new-venue suggestions. An admin console lets me review, edit, publish, or reject them.

I could have handled updates in code and skipped a real admin interface. For most side projects that’s the pragmatic call. Here it would have defeated the point: with a code-only backend, every correction becomes an engineering ticket instead of something an operator can fix from a phone in under a minute. The console also solved the fragile-entry problem, because it validates and structures a submission before it touches the live dataset.

The console runs in the browser behind magic-link sign-in. PostgreSQL row-level security constrains every read and write, so the client can never reach a row the policy forbids. Each change shows a field-level diff before it publishes, and every action goes to an append-only audit log. CI runs 512 node --test application tests plus SQL row-level-security invariant tests.

Maintaining the site is now an operations task, not a coding task. Someone else can publish a correction from their phone without touching the repository.

The public site is also built to stay up when the database doesn’t. Reads normally hit Supabase directly, but the app ships a generated per-borough snapshot of the venue data, and a dedicated checker keeps comparing that snapshot against the live database. If Supabase is unreachable, the site serves the snapshot instead of an error page. Slightly stale data is better than a broken page.

Runtime architecture diagram: the visitor's browser loads a static shell from Cloudflare; a data-source facade reads from Supabase and falls back to generated per-borough modules; the admin intake publishes to Supabase.
The runtime, from the project’s architecture notes. Every line of app code runs in the browser. A data-source facade reads Supabase first and falls back to the generated per-borough snapshot, so an outage costs freshness, not the page.

What changed once people used it

  • Venue cards, map mode, and filters became the three main ways into the data. I rebuilt them repeatedly after watching real users get stuck.
  • The same information (location, price, cuisine) got more than one access point, so it shows up where people actually look.
  • The layout is mobile-first, built for someone deciding where to go in the next twenty minutes, not browsing at a desk.
  • The correction loop keeps the dataset from drifting out of date: two intake forms, then publish or retire from the admin console.

What I learned

The most useful lesson wasn’t technical. A feature that already existed didn’t count until people could find it where they were already looking. That’s why the map, the cards, and the filters got rebuilt more than once. The rest was making trade-offs on purpose (structured strings instead of a 50-column table, an operations console instead of a code-only backend) and then paying for what those choices cost instead of pretending they were free.