I Automated My Morning Routine Into a Single Email

Every morning at 7am Pacific, two emails land. One for me, one for my wife. Each one is a personalized daily brief with everything we need to start the day. It costs $0.003 per day to run, and it replaced a 20-minute routine of checking 6 different apps.

The morning chaos before

Here's what my morning used to look like:

1. Check weather app (is it going to rain? what should the kid wear?)
2. Check calendar (any meetings before 9?)
3. Check email for anything urgent
4. Check market pre-open (I work in investment banking, so this matters)
5. Check if any packages are arriving today
6. Tell my wife the weather and kid logistics

That's 6 apps, 15-20 minutes, before coffee. And half the time I'd forget to mention a schedule change or a package arriving.

The dashboard nobody opened

My first attempt was a Notion dashboard. It had everything — weather, calendar, markets, tasks, the works. Beautiful. Comprehensive.

Nobody opened it. Not even me.

The friction of opening a browser, navigating to Notion, finding the right page — it was enough to kill it. I'd default back to checking individual apps because muscle memory is stronger than good intentions.

The insight: the delivery mechanism matters more than the content. An email that arrives at 7am gets read. A dashboard that exists somewhere gets ignored.

What's in the emails

My brief:

• Weather forecast with emoji (fastest way to parse weather at 6:58am)
• Today's calendar events with times
• Pre-market S&P 500 and 10-year Treasury moves
• Unread email count + any flagged urgent messages
• Package deliveries expected today
• Prediction market betting positions summary
• Any overnight alerts from my monitoring system

My wife's brief:

• Same weather and calendar
• Content ideas for her esthetician work (with specific hooks and trending products)
• Trending skincare products for her affiliate business
• Kid logistics (soccer practice? school events?)
• Family calendar conflicts or coordination needed

The key difference: her brief includes business intelligence for her work. It's not just "here's your day" — it's "here's your day, and here are 3 video ideas based on what's trending in skincare right now."

The newsletter noise problem

The hardest part wasn't building the brief — it was taming the inbox. I subscribe to maybe 40 newsletters. Most mornings, 15-20 are sitting unread, and they make the inbox look overwhelming.

The fix: an inbox cleanup job that runs 5 times daily. It auto-labels newsletters, archives low-priority ones, and marks promotional emails as read. By the time the daily brief runs at 7am, the inbox is already clean.

# Simplified inbox cleanup logic
NEWSLETTER_SENDERS = load_known_senders()  # ~200 senders

for email in get_unread():
    if email.sender in NEWSLETTER_SENDERS:
        label(email, 'Newsletter')
        archive(email)
    elif is_promotional(email):
        mark_read(email)
        label(email, 'Promo')
    # Everything else stays in inbox for the brief to surface

The LLM decides what's promotional using Haiku 4.5. It costs about $0.001 per email classification. For 20 emails a day, that's $0.02/day. Not zero, but close enough.

ThreadPoolExecutor: 52 seconds to 12

The original brief took 52 seconds to generate because it was serial — fetch weather, then calendar, then emails, then markets, then format, then send.

Obvious fix: do the fetches in parallel.

from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=6) as executor:
    weather_future = executor.submit(get_weather)
    calendar_future = executor.submit(get_calendar_events)
    email_future = executor.submit(get_email_summary)
    market_future = executor.submit(get_market_data)
    packages_future = executor.submit(get_package_status)
    betting_future = executor.submit(get_betting_positions)

weather = weather_future.result()
calendar = calendar_future.result()
# ... etc

52 seconds down to 12. The bottleneck shifted from API calls to the LLM formatting step, which takes about 4 seconds. The rest is just network latency for 6 parallel API calls.

This matters because both briefs need to go out at 7am. If one takes a minute, the other waits. With parallel fetching, both emails land within seconds of each other.

The $0.003/day math

Here's the actual cost breakdown per day:

Component	Cost
Weather API (Open-Meteo)	Free
Calendar API (Google)	Free
Gmail API (Google)	Free
Market data (Brave Search)	Free
LLM formatting — my brief (Haiku 4.5)	$0.001
LLM formatting — spouse's brief (Haiku 4.5)	$0.001
Inbox cleanup LLM calls	$0.001
Total	$0.003/day

That's about $1.10 per year. The VPS that runs it costs $5/month, but it runs 30 other jobs too, so the marginal cost of the daily brief is effectively zero.

The unexpected benefit

Here's what I didn't expect: both briefs landing at the same time changed how we start our day.

Before, I was the information bottleneck. "Do we have anything tonight?" "Is it going to rain?" "When's soccer?" Now my wife has her own brief with her own calendar view, her own content ideas, her own business intelligence. She doesn't need to ask, and I don't need to remember to tell her.

The briefs also became a coordination tool. When we both know the day's schedule, we can divide and conquer without a morning logistics meeting. "I saw soccer is at 4 — I'll grab them, you do the grocery run" just happens naturally because we both read the same calendar data.

It also forced us to centralize our calendars. Before this, our calendars were a mess — some stuff split between accounts, kid stuff all over the place. Making the brief useful meant getting all events into one system. The automation created the organizational discipline I never had motivation to build on its own.

How to build your own

If you want something similar, here's my honest advice:

1. Start with email delivery. Don't build a dashboard. Send yourself an email. You'll actually read it.
2. Use the cheapest LLM that works. Haiku 4.5 formats the brief perfectly. You don't need Opus for "make this weather data readable."
3. Parallelize from day one. Serial API calls are the silent killer of morning automations. If your brief takes 60 seconds, it drifts later as you add sections.
4. Build for two people. Even if you're single, think about what a second person would want. It forces you to make the system modular instead of hardcoded.
5. Run it for a week before adding features. My first brief had 12 sections. I cut it to 7 after realizing I was skimming half of them. Less is more at 7am.

The whole thing is about 400 lines of Python, runs on a $5 VPS, and has been solid for over a month. It's the single automation I'd rebuild first if I had to start over.