Forem: Josh Cox

# Failure Friday: What Quibi Teaches About Product-Market Fit

Josh Cox — Fri, 22 May 2026 18:40:43 +0000

Quibi is one of those startup failures that is interesting because, on paper, it had a lot going for it.

It had major funding.

It had experienced leadership.

It had celebrity-backed content.

It launched with a lot of attention.

And it still shut down less than a year after launch.

That is exactly why it is worth studying.

The idea was not completely ridiculous

Short-form video was already a proven behavior.

People were watching short videos on TikTok, YouTube, Instagram, Snapchat, and other platforms every day.

So the core idea of short mobile-first video was not the problem by itself.

The bigger issue was the way Quibi packaged that behavior.

It tried to turn short-form video into a paid standalone streaming service, while users were already getting short-form content for free from platforms they used every day.

That made the value proposition difficult.

A few lessons from Quibi

The first lesson is that funding does not guarantee product-market fit.

Raising a lot of money can help a company move faster, but it does not automatically mean customers want the product badly enough to pay for it.

The second lesson is that distribution matters.

Even if the content is good, people still need a strong reason to add another app, another subscription, and another habit into their lives.

The third lesson is that timing matters.

Quibi launched during a period when consumer behavior was shifting quickly, and its product did not seem to match how people actually wanted to consume short-form content.

Why I am studying failures like this

I am building Startup Graveyard as a web app for documenting failed startups and the lessons behind them.

The goal is not to make fun of companies that shut down.

The goal is to study the patterns behind failure:

Bad timing
Weak distribution
Scaling too early
No clear business model
Products people liked, but not enough to pay for

I think failure stories can be just as useful as success stories, sometimes more useful, because the patterns are often easier to see.

Startup Graveyard is live here:

https://www.startupgraveyard.co

I would also like to hear from other builders:

What failed startup do you think is worth studying?

What I'm Learning Building Startup Graveyard.

Josh Cox — Tue, 19 May 2026 13:07:50 +0000

One thing I’m noticing while building Startup Graveyard:

A failed startup is not always a bad idea.

Sometimes the timing was wrong.
Sometimes distribution failed.
Sometimes people liked the product, but not enough to pay for it.
Sometimes the market existed, but the business model did not.

That’s the part I want the site to explore more: the patterns behind failure, not just the names of companies that shut down.

Startup Graveyard is a web app where people can browse failed startups, read what happened, vote, comment, and submit their own examples.

The bigger idea is to eventually make the data useful beyond just reading individual stories. I’d like people to be able to study the patterns, compare failure reasons, look at trends, and maybe pull the data in a way that helps founders, builders, students, and researchers learn from it.

The technical side has been a big learning process too. I’ve been working with Next.js, Supabase, authentication, profiles, moderation, SEO, and deployment through Vercel.

It started as a simple project to learn about web dev, deployment, and to finally see one whole idea through.

Hopefully this project inspires people to learn from others mistakes!

https://www.startupgraveyard.co

I Built Startup Graveyard to Study Why Startups Fail

Josh Cox — Mon, 18 May 2026 01:46:37 +0000

I recently soft-launched a side project called Startup Graveyard.

The idea is simple: a place to browse failed startups, learn what went wrong, and pull lessons from their mistakes.

You can check it out here:
https://www.startupgraveyard.co

Why I built it

I have always been interested in startups, software, and the idea of building something from scratch. But the more I looked into successful companies, the more I realized that failed startups are just as useful to study.

A lot of failed startups had good ideas, talented teams, funding, users, or hype. But something still went wrong.

Sometimes it was poor timing.
Sometimes there was no real market need.
Sometimes the business model did not work.
Sometimes the product was interesting, but not useful enough for people to keep using.

I wanted to build a site that collects those stories in a simple, searchable way.

What the app does right now

Startup Graveyard currently lets users:

browse failed startups
search and filter by category
sort by newest, top, or A-Z
view startup detail pages
upvote startups
comment on startup pages
create an account
submit failed startups
manage their own submissions from a profile page

New submissions go into a pending review state before they appear publicly, so the site does not become a spam board.

Tech stack

I built it with:

Next.js
TypeScript
Tailwind CSS
Supabase for auth and database
Supabase RLS for security rules
Resend for production auth emails
Vercel for deployment

This project also helped me get more comfortable with real-world production concerns like:

authentication
email confirmation
row-level security
moderation
SEO metadata
sitemap and robots files
environment variables
deployment issues
preventing public email exposure
keeping user-submitted content controlled

What I learned

The biggest lesson from building this was that launching an app is not just about making the UI work.

There were a lot of things I had to tighten up before I felt comfortable sharing it publicly:

user emails should never show publicly
new submissions need moderation
users should not be able to self-approve their own posts
auth emails need production SMTP
database rules matter more than client-side checks
SEO needs to be handled before sharing links
a feature can work in development but still need production hardening

The app started as a simple directory, but it quickly became a good learning project for how real apps are built and protected.

What I want to add next

The next big improvement I want to make is a better failure pattern system.

Instead of only showing a basic cause of death, I want startups to be grouped by patterns like:

no market need
pricing failure
poor timing
distribution failure
funding or burn-rate issues
legal or regulatory problems
retention problems
founder conflict
competition
hardware/manufacturing issues

Long term, I would like the site to become more of a learning engine for founders and builders, not just a list of failed companies.

Feedback welcome

This is still a soft launch, so I would really appreciate feedback.

I’m especially looking for thoughts on:

the overall idea
design and usability
anything confusing in the flow
features that would make the site more useful
bugs or rough edges

Site:
https://www.startupgraveyard.co

Thanks for checking it out.

I’m Building a Startup Failure Archive With Next.js and Supabase

Josh Cox — Thu, 14 May 2026 18:16:05 +0000

I’m building a project called Startup Graveyard.

The idea is simple: a searchable collection of failed startups and post-mortems so builders can learn from what went wrong instead of only seeing success stories.

It’s built with Next.js, Supabase, and Vercel. So far I’ve added auth, startup submissions, comments, voting, profiles, and filtering.

I’m still polishing it, but I’m thinking about writing a dev.to post about the build process, what I learned, and some of the mistakes I ran into along the way.

Would this be something worth sharing?

Hey everyone, First time posting on dev.to and first time entering a coding challenge here, so I figured I’d introduce myself a bit. I currently work as a machine operator while finishing my degree in Computer Information Systems, and I’ve been trying to

Josh Cox — Fri, 08 May 2026 18:26:28 +0000