Part 4 of the Product Onion Series

My wife found me at 11 PM on a Tuesday, staring at three different apps on my phone, a notebook open on the kitchen counter, and a whiteboard covered in arrows connecting random tasks.

“What are you doing?” she asked.

“Trying to figure out why we never have dinner ingredients,” I said.

She looked at the whiteboard. “Is that… a flowchart?”

“It’s a system.”

“It’s chaos.”

She was right.

I had built an elaborate meal planning system with grocery lists, recipe databases, and scheduling tools. I had color-coded categories. I had tags and filters. I had automation.

And we still ordered takeout four nights a week.

Funny thought just came over me. My good friend, colleague and manager remarked he loved the fact that I had a paper planner with six different colored highlighters neatly arrayed on the front cover of the planner so I could visually identify my key areas for the day. I digress, but it gives you the idea of the elaborate planning we can fall into.

That’s when it hit me: I was managing my personal life the same way I used to build businesses—from the outside in. Starting with tools and systems before understanding the actual problem I was trying to solve.

So I did something radical. I applied the Product Onion framework to my own life.

This is what happened.

The Problem With Personal Productivity (And How We’re All Doing It Wrong)

Here’s the pattern I see everywhere:

Someone feels overwhelmed → They buy a productivity app → They spend hours setting it up → They use it for three weeks → They feel guilty when it stops working → They buy a different app

Sound familiar? I call it the shiny new toy syndrome. Our young children would manifest this same behavior every Christmas.

The issue isn’t the tools. It’s that we’re starting with Layer 6 (execution) before we understand Layer 1 (the problem).

We’re trying to optimize systems for problems we haven’t clearly defined.

Let me show you what changed when I stopped doing that.

Layer 1: Finding the Core Problem (It’s Not What You Think)

What I Thought the Problem Was:

“We don’t have a good meal planning system.”

What the Problem Actually Was:

After two weeks of actually tracking our behavior (not what we wished we did, but what we actually did), here’s what I discovered:

Monday: Got home at 7 PM, exhausted. Looked in fridge. Had ingredients for three different incomplete meals. Ordered Thai food.

Tuesday: Planned to make pasta. Realized we were out of garlic (again). Too tired to go to store. Ordered pizza.

Wednesday: Had ingredients. Started cooking. Recipe took 45 minutes longer than expected. Kids had meltdown. Everyone cranky. Regretted not ordering out.

Thursday: Tried to use leftover chicken from Sunday. It had gone bad. Threw it away. Ordered Mexican.

The pattern wasn’t “we need better meal planning.”

The pattern was: Decision fatigue + uncertainty + energy mismatch = takeout

The Real Core Problem:

By the time we get home on weeknights, we’re too depleted to make good decisions, too uncertain about what we can actually cook in our energy state, and too aware of potential failure points (missing ingredients, recipes taking too long, things going wrong) to commit to cooking—so we default to the path of least resistance even though we’d prefer to eat at home.

That’s the real problem.

Not planning. Not organization. But decision fatigue meets uncertainty at the exact moment when energy is lowest.

Once I understood that, everything changed.

Layer 2: Domain Logic & Strategy (The Approach That Actually Works)

Most meal planning systems try to solve this by adding more structure: weekly meal plans, batch cooking Sundays, elaborate prep systems.

But more structure requires more energy. And energy is exactly what we don’t have.

So, I went the opposite direction.

Strategic Pillars:

Pillar 1: Eliminate Decisions, Not Meals

Instead of planning every meal, We created three “decision-free zones”:

• Monday & Wednesday: Always pasta night (6 variations, all ingredients permanently stocked)
• Tuesday & Thursday: Always “bowl night” (grain + protein + veg, plug-and-play)
• Friday: Always pizza (homemade dough, various toppings, fun family activity)

Weekend? That’s when we have energy for variety and experimentation.

Pillar 2: Energy-State Matching

I rated every recipe in our rotation by energy requirement:

• Low energy (20 min, minimal decisions): Aglio e olio, rice bowls, quesadillas
• Medium energy (35 min, some decisions): Stir-fry, sheet pan dinners, simple curries
• High energy (60+ min, complex): Lasagna, tagine, homemade ramen

Then I matched them to predictable energy patterns. Monday after work? Low energy only.

Pillar 3: Failure-Proof Inventory

Instead of shopping for specific recipes, I maintain a “possibility inventory”:

• Core pantry (pasta, rice, canned tomatoes, beans, stock—never run out)
• Protein rotation (whatever’s on sale, frozen backup always available)
• Fresh three (always have: garlic, onions, leafy greens)

You can make 40+ meals from those categories. No specific recipe is required.

Pillar 4: 15-Minute Rule

If actual cooking time exceeds 15 minutes, it’s a weekend recipe. Weeknights are about assembly, not cooking.

This meant rethinking what “cooking” means. Pre-cooked grains. Pre-portioned proteins. Pre-chopped aromatics (yes, I buy the jarred garlic now—fight me).

Layer 3: Features & Functionality (The Actual Systems)

Now—with strategy in place—I could build systems that served the strategy.

System 1: The Weekly Reset (Sunday, 20 minutes)

Not meal planning. Inventory check.

• Check pantry core items (restock anything missing)
• Check protein (3+ options available?)
• Check fresh three (restock)
• Prep one thing (pre-cook rice, chop vegetables, make dough)

That’s it. No elaborate meal plans. No recipes selected. Just ensuring possibility.

System 2: The Decision Board (Kitchen Whiteboard)

Three columns:

• Low Energy Options (what you can make in 20 min)
• Medium Energy Options (if you’re feeling okay)
• Emergency Backup (frozen pizza, pasta aglio e olio, eggs)

When we get home: Look at board, assess energy, pick from appropriate column. 30 seconds, decision made.

System 3: The Floating Grocery List (Shared App)

Not a weekly shopping list. A running inventory.

Out of pasta? Add it immediately. Last onion used? Add it immediately.

Never shopping for specific recipes. Always maintaining possibility inventory.

System 4: The Recipe Archive (Notion Database)

Every recipe we actually make gets logged with:

• Energy requirement (low/med/high)
• Actual time (not recipe time—real time)
• Pantry ingredients needed
• Success rate (did it work? Would we make it again?)
• Notes (what went wrong, what to adjust)

After 6 months, I can see patterns: We make 12 recipes on repeat. Everything else is experimentation. So, I stopped pretending we needed variety every night.

Layer 4: User Experience (Making It Effortless)

The systems only work if they’re actually easier than ordering takeout.

UX Principles I Applied:

Principle 1: Visibility Over Memory

The decision board is in the kitchen, visible when we walk in. We don’t have to remember options or open an app. It’s just there.

Principle 2: Minimal Friction

Shared grocery list with auto-syncs. Whoever’s at the store can grab items. No asking “did you add milk?” No separate lists.

Principle 3: Forgiveness, Not Perfection

Emergency backup is ALWAYS an option. No guilt. No “we failed again.” It’s literally on the board as a valid choice.

Principle 4: Energy-Appropriate Defaults

If we’re too tired to decide, there’s a standing rule: Monday = cacio e pepe, Tuesday = grain bowl, Wednesday = carbonara. No decision is required. Autopilot mode.

The UX Test:

Can we go from “walking in the door exhausted” to “cooking started” in under 3 minutes?

If not, the system needs simplifying.

Layer 5: Communication & Documentation (Making It Transferable)

Here’s where most personal systems fall apart: They live in one person’s head.

My wife would ask: “What should we make tonight?”

And I’d have to explain the whole system, check the inventory, suggest options…

That’s a bottleneck. That’s decision fatigue for her.

So, I made the system transparent and shared.

Communication Elements:

The Decision Board: Both of us can see options at a glance

The Recipe Database: Searchable by energy level, time, and ingredients on hand

The Grocery List: Shared access, real-time sync

The Weekly Reset Checklist: Written protocol, anyone can do it

The “Why” Document: One-page explanation of the strategy (so it’s not arbitrary rules)

This matters because: A personal system that requires one person to be the bottleneck isn’t a system—it’s a dependency.

Layer 6: Execution & Habits (How We Actually Do It)

All the strategy and systems mean nothing if we don’t actually use them.

Habit Architecture:

Trigger 1: Walking In the Door

→ Immediate glance at decision board → 30-second energy assessment → Pick from appropriate column → Start cooking or defer to emergency backup

Trigger 2: Sunday Morning Coffee

→ 20-minute weekly reset while coffee is brewing → Becomes associated with relaxation, not work

Trigger 3: Running Out of Something

→ Add to list immediately (phone is always nearby) → No trying to remember later

Trigger 4: After Cooking

→ 2-minute debrief: What worked? What didn’t? → Update recipe notes if needed

The Habit That Changed Everything:

No decisions after 6 PM on weeknights.

We pre-decide on weekends or during high-energy moments. By the time evening exhaustion hits, we’re executing, not deciding.

This applies to more than meals: What we’re watching, whether we’re working out, what time we’re going to bed.

Evening us is terrible at decisions. So, we don’t let evening us make them.

The Results (Actual Numbers, Not Aspirations)

Before Product Onion Approach:

• Ordered takeout/delivery: 4-5 nights per week
• Threw away spoiled food: ~$60/month
• Felt guilty about not cooking: Constantly
• Time spent “figuring out dinner”: 20-45 minutes of debate
• Success rate when we did cook: ~60% (often too long, too complex, missing ingredients)

After Product Onion Approach (6 months in):

• Order takeout/delivery: 1-2 nights per week (and it’s intentional, not default)
• Throw away spoiled food: ~$15/month
• Feel guilty: Rarely (emergency backup is valid choice)
• Time for deciding dinner: 2-3 minutes
• Success rate: ~90%
• Money saved: ~$420/month
• Sanity gained: Immeasurable

But Here’s the Real Metric:

We enjoy cooking again.

Because we’re not deciding whether to cook. We’re not scrambling for ingredients. We’re not attempting recipes beyond our energy state.

We’re executing a system that serves our actual lives, not an aspirational version of ourselves.

How This Applies to Everything Else

Once I cracked this for meals, I realized: The Product Onion works for every life system.

Home Maintenance (Layer 1: Problem)

Wrong problem: “We need a better system for tracking home repairs”

Real problem: “Small issues compound into expensive emergencies because we don’t notice them until they’re urgent, and by then we’re in crisis mode making expensive reactive decisions”

Solution: Monthly 15-minute “home audit” walk-through. Issues get triaged into prevention buckets (DIY now, schedule pro, monitor). Small fixes happen before they’re expensive.

Exercise (Layer 1: Problem)

Wrong problem: “I need more motivation to work out”

Real problem: “I have to make too many decisions (when, what, where, how long) at the exact moment when willpower is lowest, so friction beats intention”

Solution: Pre-decided workout times (Mon/Wed/Fri, 6 AM), pre-selected workout (5 rotations, never decide day-of), gym bag always packed by door, zero-decision execution

Financial Planning (Layer 1: Problem)

Wrong problem: “We need a better budgeting system”

Real problem: “We don’t have visibility into where money actually goes until after it’s spent, so we can’t make intentional trade-offs in the moment”

Solution: Not a budget. An allocation system. Every dollar gets assigned a purpose when it arrives, not when it’s spent. Automated transfers, spending from designated accounts, real-time visibility.

The Pattern (Why This Works for Life, Not Just Business)

Here’s what I’ve learned applying the Product Onion to personal systems:

Lesson 1: Most “productivity” problems are actually clarity problems

We don’t need better tools. We need clearer understanding of what we’re actually trying to solve.

Lesson 2: Strategy before systems

Systems without strategy create busy work. Strategy without systems stays in your head. You need both, in that order.

Lesson 3: Design for your actual self, not your aspirational self

Your system should work for tired, stressed, end-of-day you. Not the motivated, energized, morning version of you who designs the system.

Lesson 4: Reduce decisions, not effort

Effort is fine. Decision fatigue is the killer. Front-load decisions when you have energy so you can execute on autopilot when you don’t.

Lesson 5: Visibility beats memory

If you have to remember it, you’ll forget it. Make everything visible, shared, and accessible.

The Meta-Lesson (Why This Matters)

Here’s the thing about applying business frameworks to personal life: It sounds cold. It sounds like you’re “optimizing” your life instead of living it.

But that’s backwards.

The Product Onion isn’t about efficiency for efficiency’s sake. It’s about removing friction from the things that don’t matter so you have energy for the things that do.

I don’t want to spend 45 minutes every night debating what to eat and scrambling for ingredients.

I want to spend that time with my family. Playing with my kid. Having actual conversations with my wife. Working on projects I care about.

The system isn’t the point. The freed-up capacity is the point.

And that’s the exact same lesson from building businesses:

Get the foundation right (Layer 1: Core Problem) and everything else becomes easier.

Skip the foundation and you’re constantly firefighting, regardless of how many productivity apps you buy.

Your Turn (The Exercise)

Pick one area of your life that feels chaotic or draining.

Don’t start by looking for a system or tool.

Start by asking: What’s the actual problem?

Not “I need better organization.”

But: “When does friction happen? What decision am I making at the worst possible time? What’s the pattern beneath the chaos?”

Write it down. Be specific. Use real examples from your life.

Then ask: What strategy would eliminate the core friction?

Not “what app should I use” but “what approach would make this effortless?”

Only then—after problem and strategy are clear—start building the systems.

That’s the Product Onion for life.

Inside out. Always.

---

Next time: We’re bringing all three case studies together. How Trevean Living, Trevean Spice, and Home Project Systems share the same DNA—and what that teaches us about building anything that lasts.

---

What’s one area of your life that needs the Product Onion treatment? Drop a comment and I’ll help you identify the core problem.