I Automate My Weekly Groceries with a Single Tap, and Here Is the Script

Sunday evenings used to be the specific time when my productivity system collapsed. It wasn't about work; it was about the domestic operational tax of planning meals and restocking the fridge for the week ahead. For years, this involved a cognitive split: maintaining a list in a task manager and then manually transcribing those items into a delivery app’s search bar. The friction was subtle but expensive, roughly forty-five minutes of duplicated effort every week.

In early 2026, I decided to treat this not as a chore, but as a workflow failure. The goal was to reduce the interaction to a single tap, requiring zero manual entry after the initial thought capture. The solution involved bridging Things 3—where I already capture my thoughts—with a delivery API using iOS Shortcuts. This wasn't just about saving time; it was about removing the mental load of "translation" between my capture system and the execution layer.

The Hidden Cost of the "Manual Bridge"

Most productivity advice focuses on capture, but execution is where efficiency is usually lost. My previous workflow was standard: whenever I ran out of milk or decided I wanted to cook a specific curry, I’d type it into Things. On Sunday, I’d open the grocery delivery app, search for "Almond Milk", add it to the cart, search for "Red Lentils", add it, and so on.

This process is riddled with friction. Every search is a micro-decision. Am I buying the 1-liter or the half-gallon? Which brand is on sale? For someone who values deep work, this low-stakes decision fatigue is surprisingly draining. It violates the core principle I discussed regarding why the "one app to rule them all" approach is flawed; I was trying to force a task manager to do a job that required a commerce engine.

I realized I needed a "middle layer"—a script that could read my intent from the list app and "speak" directly to the grocery store's digital infrastructure.

Designing the Architecture

The architecture for this automation relies on three pillars: a standardized list format, a parsing logic, and an API endpoint. Since I live in the Apple ecosystem, I used Shortcuts as the glue, but the logic is replicable in Tasker on Android.

I designated a specific Project in Things titled "Groceries." The rule for myself was simple: every item must be entered as the exact product name found on the store's website. If I want "Organic Whole Milk 1 Gallon," I cannot just write "milk." This discipline is the prerequisite for automation.

The delivery service I use (Instacart, or a regional equivalent with exposed endpoints) allows for adding items to a cart via a POST request. I obtained my API key through their developer portal—many grocery aggregators offer this now for enterprise clients, though some users manage this through third-party wrappers like Zapier or Make.com if they lack direct API access.

Breaking Down the Script

Here is the actual logic flow of the Shortcut I named "Sunday Restock." It runs automatically at 6:00 PM on Sundays via a Personal Automation, but I keep a widget on my home screen for manual triggers.

Step 1: Fetch the Content The script begins with the "Find Things" action. It targets the "Groceries" project and pulls the contents of the to-dos. It grabs the name of each to-do, ignoring the notes and deadlines.

Step 2: Regex Parsing (The Brain) This is the most critical part. Humans write lists messily. We might write "2x Bananas" or "Chicken breast, 1 lb." The script uses the "Match Text" action with Regex. The pattern (\d+)\s*(.*) separates the quantity from the item name.

• Group 1 becomes the Quantity.
• Group 2 becomes the Item Name. If no number is found, the Quantity defaults to "1".

Step 3: Dictionary Construction The API doesn't accept a raw string; it needs a JSON object. The Shortcut loops through every item found in Things. For each item, it adds a new entry to a Dictionary with these keys:

• product_id: We will map the text to an ID (or use the text search parameter if the API supports fuzzy matching).
• quantity: The number parsed in Step 2.

Step 4: The API Request We construct the URL endpoint. In this case, it is a POST request to /v1/carts/add. The Headers include:

• Authorization: Bearer [My-API-Token]
• Content-Type: application/json The Body of the request is the Dictionary we just built. We pass that dictionary into "Get Contents of URL."

Step 5: Completion and Cleanup Once the request returns a 200 OK status, the script doesn't just stop. It uses the "Delete Things" action to clear every item in the "Groceries" project. This provides a clean state for the following week. Finally, it sends a notification: "Cart updated with 18 items. Ready to checkout."

The Sunday Evening Execution

The first time I ran this, I sat on my couch staring at my phone, waiting for an error message. Instead, a notification popped up: "Cart updated with 14 items." I opened the delivery app, and there it was—my full shopping list, parsed correctly with quantities, sitting in the digital cart.

The time saving is measurable. I save roughly 4 minutes per item by skipping the search, selection, and "add to cart" animation loop. With an average of 20 items a week, that is 80 minutes saved monthly. However, the cognitive saving is higher. I no longer have to context-switch between "planning mode" and "shopping mode."

There is a caveat, of course. If the API changes or the specific SKU for my favorite almond milk is discontinued, the script might fail to add that specific item. To mitigate this, I added an error-handling step: if the API returns anything other than 200 OK, the script sends me a notification listing the specific item that failed, allowing me to add it manually.

The Trade-Offs of Automation

This workflow is not "set it and forget it" in the purest sense. It requires a rigid input discipline. If my partner types "milk" instead of "Horizon Organic Whole Milk 1 Gal," the script will likely add a random milk product or fail to find a match.

Furthermore, automating the cart population does not automate the checkout. For security and financial control, I refuse to script the payment processing. I still need to open the app, review the substitutions (the script can't tell if the avocados look bruised), and pay. This is a feature, not a bug. It keeps me in the loop for final approval while outsourcing the drudgery of data entry.

Reclaiming the Head Space

By removing the manual entry of groceries, I reclaimed a surprising amount of mental bandwidth. Sunday evenings are no longer defined by the dread of "ordering food." They are now just for planning what to eat, while the logistics are handled silently in the background.

If you are looking to build a similar system, start by auditing your list app. Ensure it can export text or is accessible via URL schemes (like Things or Todoist). Then, look at your delivery provider's documentation. You don't need to be a developer to build this; you just need to be willing to treat your groceries as data points.

This specific bridge—the connection between a thought in a task manager and a physical item in a delivery cart—is where modern productivity is moving. It is no longer about just remembering to do the task; it is about lowering the activation energy required to get it done.

Ultimately, the most effective productivity tools are the ones that disappear. After a month of running this script, I stopped thinking about the technology. I just think "we need eggs," type it into Things on Tuesday, and on Sunday, the eggs are in the cart. That frictionlessness is the only metric that matters.