fujin lei

Posted on Jan 20

I Built a Meal Randomizer Because I'm Too Tired to Decide What to Eat

#javascript #webdev #showdev #productivity

The Problem: 6 PM Decision Paralysis

You know that feeling when you get home from work, open the fridge, and just... stare?

Your brain is fried. You have ingredients. You could make something. But the mere thought of deciding what to make feels like climbing a mountain.

That was me. Every. Single. Day.

I'd spend 20 minutes scrolling through recipe apps, only to end up ordering takeout because I was too exhausted to make a decision.

So I built the simplest possible solution: a meal randomizer that makes the decision for me.

The Solution: Zero Decisions, Just Dinner

Check it out: Lazy Vegan

Here's how ridiculously simple it is:

Open the app
It shows you a random meal (like "BLT Sandwich" or "Burrito Bowl")
You see the ingredients and steps
You cook (or skip and get a new one)

That's it. No meal planning. No scrolling. No thinking.

Why It Works: The Psychology of Constraints

Here's the controversial part: you can only skip twice.

I know what you're thinking: "Why limit user freedom? That's terrible UX!"

But here's what I learned: decision fatigue is the enemy, not lack of options.

When I had unlimited skips in the first version, I'd click "skip" 10+ times, essentially recreating the exact problem I was trying to solve. I was scrolling through recipes again, just in a different interface.

The 2-skip limit forces you to actually commit. And you know what? It works. Most of the time, the first random meal is fine. You're tired anyway — you don't actually care if it's a BLT or a burrito bowl. You just need someone to decide for you.

The Tech Stack: Aggressively Boring

I intentionally kept this as simple as possible:

// The entire core logic
async function loadMeals() {
  const response = await fetch('meals.json');
  const meals = await response.json();
  return meals;
}

function getRandomMeal(meals) {
  const randomIndex = Math.floor(Math.random() * meals.length);
  return meals[randomIndex];
}

No framework. No build step. No backend.

Just:

Vanilla JavaScript
Static JSON file with 20 recipes
CSS with custom properties
Hosted on static hosting (basically free)

Why No React?

Because I didn't need it. This app:

Doesn't have complex state management
Doesn't have user authentication
Doesn't have real-time updates
Has maybe 100 lines of JS total

Using React would've been like bringing a chainsaw to cut a sandwich.

The Recipe Design: Intentionally Lazy

Every recipe follows strict rules:

✅ Must use pre-cooked or instant ingredients

{
  "title": "Burrito Bowl",
  "ingredients": [
    "Microwaveable rice pouch",  // Not "uncooked rice"
    "Canned black beans",         // Not "dried beans"
    "Pre-cooked chicken strips"   // Not "raw chicken"
  ]
}

✅ Maximum 5 steps, each under 10 words

❌ No "season to taste" or "cook until golden"

Why? Because when you're exhausted, every decision is taxing:

"How much salt?"
"What does golden even look like?"
"Do I have that spice?"

Specific, brain-dead simple instructions only.

Code Walkthrough: The Skip Limit

Here's how I implemented the 2-skip limit:

let skipCount = 0;
const maxSkips = 2;

function handleSkip() {
  skipCount++;

  // Hide skip button after 2 skips
  if (skipCount >= maxSkips) {
    document.getElementById('skip-button').style.display = 'none';
  }

  renderNewMeal();
}

Simple, but effective. Once you've skipped twice, you're committed to whatever comes up next.

Some users might hate this. But my target audience (exhausted people who can't make decisions) love it. It removes the burden of choice.

Performance: Insanely Fast

Since everything is static:

First contentful paint: ~0.3s
Time to interactive: ~0.5s
Bundle size: ~8KB (uncompressed)
API calls: 1 (to fetch meals.json)

No spinners. No loading states. Just instant.

What I Learned: Solve YOUR Problem First

Initially, I thought "this is too simple, nobody will use it."

Then I remembered: I built this for me. If it solves my problem, it probably solves others' too.

Turns out, decision fatigue is universal. Especially for:

Busy professionals
Parents
Students
Anyone who works long hours

The app isn't trying to be the next meal planning giant. It's solving one specific problem: what to eat when you're too tired to think.

The "Vegetarian" Paradox

Sharp-eyed readers might notice: the recipes aren't all vegetarian. There's chicken, shrimp, tuna, bacon.

The original concept was "lazy vegan," but I realized:

Pre-made vegan meals are harder to find
My actual problem was decision fatigue, not veganism
The name "Lazy Vegan" was catchy, so I kept it

Is this false advertising? Maybe. But the subtitle says "This works even if you're tired" — not "This is 100% vegan." And honestly, tired people don't care about the name; they care about dinner.

Try It Yourself

👉 www.lazyvegan.space

The whole project is intentionally minimal. You could rebuild it in an afternoon. But that's the point — not every problem needs a complex solution.

Sometimes you just need a button that says "make this thing" so your tired brain can stop deciding.

Tech Details for the Curious

Frontend:

Vanilla JS (ES6+)
CSS Custom Properties for theming
Google Fonts (Nunito + Outfit)
Responsive design (mobile-first)

Hosting:

Static file hosting (Netlify/Vercel/CloudFlare Pages)
No server, no database
Cost: $0/month

Data Structure:

{
  "id": "1",
  "title": "Burrito Bowl",
  "ingredients": ["..."],
  "steps": ["..."]
}

Lessons Learned:

Constraints can improve UX (the 2-skip limit)
Boring tech is reliable tech (vanilla JS just works)
Solve your own problem (I use this 3-4x/week)
Simple doesn't mean easy (took several iterations to get the UX right)

What's Next?

Honestly? Probably nothing major. The app works. It's fast. It's simple.

Maybe I'll add:

Dietary filters (actual vegetarian/vegan options)
Ability to favorite meals
A "surprise me" mode with no skips at all

But then again, adding features might ruin the simplicity. And simplicity is the whole point.

What do you think? Would you use something like this? Or am I the only one who stands in front of the fridge, brain completely off, unable to decide what to eat?

Drop a comment — I'd love to hear if you have similar decision fatigue issues (and how you solve them).

P.S. — If you found this useful, give it a ❤️ and share with your tired friends. We're all just trying to eat dinner without thinking too hard.

DEV Community