Currently offline

Plan / Prep / Plate

A recipe app that actually shipped. Revenue just never followed.

CookCloud was a full meal-planning platform: search, import, plan, shop, track. The product worked. Getting people to pay for it never did, partly because I kept shipping new features instead of fixing that. So I pulled the plug. Here's the whole thing, unfiltered.

Plan · Prep · Plate

What actually shipped

This isn't a landing-page mockup. It's a working product people used, and everything marked shipped below ran in production.

Under the Hood

What ran underneath it

The launch post covered the AI coding tools I built it with. This is the part it didn't cover: what actually had to run, all day, every day, for CookCloud to stay up.

Application

  • Django 5.2— core framework, Python 3.13
  • Django Channels + Daphne— async/WebSocket layer
  • Django CMS— blog & marketing pages
  • django-allauth— auth, MFA, social login
  • DRF + drf-spectacular— API + docs

Data & jobs

  • PostgreSQL— primary datastore
  • Redis— cache, broker, sessions
  • Celery + Celery Beat— background & scheduled jobs
  • django-storages + S3— media & image storage

Intelligence

  • OpenAI API— recipe parsing & suggestions
  • Spoonacular API— nutrition & ingredient data
  • AbacusAI— recommendation modeling
  • yt-dlp— recipe import from video

Money & ops

  • Stripe + dj-stripe— subscription billing
  • Mailgun— transactional email
  • Sentry— error tracking
  • GeoIP2 + django-health-check— access & uptime
This is a real SaaS stack, not a script. Postgres, Redis, a Celery worker, a Celery Beat scheduler, and an async web process all had to run continuously, at the same time, just for the app to function. Five always-on processes before a single user loads a page. It's the right architecture for what CookCloud does, and it meant the app needed paying subscribers to make sense financially (more on that below).
The Honest Part

Why the kitchen closed

Revenue never really got off the ground. Five always-on services and three metered APIs need paying subscribers behind them, and I spent my time building instead of finding those subscribers.

Paying subscribers at shutdownzero
Always-on services required to run the appfive
Shipped features (search, import, planning, lists, subs, nutrition, prep mode)seven
Of those, polished enough to convert a visitor into a subscriberfew
Weeks spent marketing what already existednot enough
A real product that never found paying usersthe actual problem

CookCloud never found paying users. That's the plain version, and everything else is a more comfortable way of saying it. A recipe app running on Postgres, Redis, Celery, and metered AI APIs needs subscribers behind it to make sense, and revenue just never got there.

The mistake wasn't the tech. It was where I spent my time. Every time a core feature felt slightly rough, my instinct was to build the next feature instead of polishing the one already in front of me. Search, meal planning, and grocery lists all deserved more attention than they got before I moved on to ingredient substitutions, then started scaffolding a recommendations engine nobody had asked to use yet. Telling people CookCloud existed barely happened at all.

So I took it down rather than let it quietly bleed money every month. The code still works, and the idea still holds up — but a relaunch means doing the boring part first: pick two or three features, make them genuinely great, and actually tell people about it before starting anything new.

Reservation list, not a mailing list

If enough people want it back, I'll bring it back.

One email, no spam. If this list gets big enough to justify the hosting bill, you'll be the first to know CookCloud is cooking again.

Used only to notify you about CookCloud. Unsubscribe anytime. Privacy policy