Inspiration

One of our teammates has a work stipend for DoorDash which is a great perk, but one that came with an unexpected problem. Wanting to order something both good and healthy, they found themselves scrolling for almost an hour, trying to piece together whether a meal would actually hit their nutrition goals. No app made that easy as you either track macros manually after the fact, or you guess and hope.

That frustration became our starting point. We realized this wasn't a one-off annoyance but instead, it's a problem anyone trying to eat intentionally while ordering out runs into. So we set out to build MacroMe, an agent that removes that decision fatigue entirely.

What it does

MacroMe is a web agent that fills your DoorDash cart based on your daily macronutrient goals. It's not just a recommendation list, but an agent that actually browses menus, reasons about what to order, and builds your cart for you.

You set your macro targets (protein, carbs, fat, calories), number of meals, budget, and delivery details
MacroMe browses supported restaurants, using published nutrition data so its picks are grounded in real numbers, not guesses
It selects a combination of items that fits your remaining macro budget and your spending limit
It adds those items directly to your DoorDash cart and shows its reasoning for every pick
You review the cart and complete checkout yourself - MacroMe gets you 90% of the way there, you make the final call

How we built it

MacroMe is built in Node/TypeScript around a real browser agent, grounded nutrition data, and persistent scheduling. We use Steel + Playwright to run a remote Chromium session that browses and interacts with the actual DoorDash website, with a saved Steel profile handling persistent login sessions. Restaurant menus are matched against a locally queryable USDA nutrition database, giving the agent grounded nutrition estimates rather than relying on LLM guesses. An LLM via OpenRouter then selects items based on the user's remaining macro targets and budget.

The agent builds the DoorDash cart automatically and pauses at the review step, leaving final checkout to the user. A lightweight cron-style scheduler handles recurring meal runs and persists state, while daily logs generate macro summaries and optional email digests through Resend. An Express + vanilla JS dashboard ties everything together with onboarding, live browser feeds, cart approval, macro tracking, and meal history. We also built explicit recovery and fallback paths for real-world browser failures like changing menus, unavailable stores, and failed cart actions.

Challenges we ran into

Building an agent that interacts with a real website was much messier than building one that talks to an API. DoorDash menus change, stores go unavailable, elements can fail to load, and browser sessions can stall mid-run. We had to build explicit recovery and fallback paths instead of assuming every run would go perfectly.

Logging in was its own obstacle. DoorDash's two-factor authentication meant the agent couldn't just submit a username and password - it also needed to retrieve a one-time code sent to email before it could get past login. We solved this by integrating Resend, which let us programmatically fetch the verification code from Gmail and feed it back into the login flow, so the agent could authenticate end-to-end without a human manually copying a code over.

We also had to solve the gap between LLM reasoning and reliable nutrition data. Rather than letting the model guess macros, we built a local USDA nutrition database and used it to ground the agent's candidate picks before asking the LLM to optimize the meal.

Accomplishments that we're proud of

We built an agent that goes beyond recommending food: it can browse DoorDash, reason about remaining macros and budget, build the cart, and schedule future meals automatically. One feature we are especially proud of was making the system resilient enough to handle real-world browser failures while still keeping the user in control. MacroMe can run the entire planning-to-cart loop, but deliberately stops before payment so the user always has the final say.

What we learned

We learned that building agents for real-world environments is less about getting the "happy path" working and more about handling everything that can go wrong. Browser automation requires constant validation, recovery, and fallbacks.

We also learned how important it is to give LLMs good structured inputs. Grounding the model with real nutrition data and a constrained set of menu candidates made its reasoning much more reliable than asking it to figure everything out from scratch.

What's next for MacroMe

Next, we want to make MacroMe smarter at learning from past meals and preferences, improve its understanding of restaurant menus and nutrition data, and make scheduling and meal planning more flexible.

We also want to expand beyond a single ordering platform and eventually make MacroMe capable of handling the entire meal-planning loop across restaurants and services.