How to Identify One or Two Tasks You Do Daily That Can Be Automated (Do It)

We define automation broadly: anything that reduces steps and decisions for a task we perform at least 5 days a week. That can be:

• A canned email or text expansion (e.g., typing “/meet” expands to our booking link and 2 lines of polite context).
• A rule that moves and renames files as soon as they land in a folder.
• A mobile shortcut that takes a picture of a receipt and logs the vendor + amount into a sheet, then archives the photo.
• A booking link so we stop negotiating times by email.
• A one-tap button that starts a timer and opens today’s template for a daily meeting.

We are not trying to build a robo-life. We are shaving 60–300 seconds off a handful of standardized loops.

We start with a tiny log—ten minutes, max. We sit down with coffee and write the last 24 hours as actions, not feelings:

• 07:52 copied Zoom link and wrote “See you at 10:00” – 90 seconds
• 08:10 downloaded invoice.pdf, renamed to “VendorName_2025-10-02.pdf” and moved to “Taxes/2025” – 2 minutes
• 12:21 typed the same three-line Slack update for daily standup – 1 minute
• 16:05 opened spreadsheet, added “Taxi 22.40” from email receipt – 2 minutes
• 18:02 proposed times to friend for coffee and pasted calendar link – 3 minutes

Then we score:

• Frequency per week (F): 5–20
• Duration per instance (D): 0.5–5 minutes
• Error/annoyance risk (E): low/medium/high
• Automatable (A): yes/no with our current tools

We compute weekly minutes saved: F × D. Anything above 10 minutes/week earns attention. We double-tag anything we feel mild dread about (“ugh, this again”).

A small trade-off shows up here. Some tasks are short but high-friction (renaming files feels fiddly), others are longer but happen less (end-of-month tally). For this hack, we exclude anything that occurs fewer than 5 times/week. High-volume beats high-drama.

Decision moment: our two candidates We’ll model with two tasks that cover most people.

• Candidate 1 (Communication): meeting scheduling. Replace manual back-and-forth with a booking link + text expansion. Typical save: 2–5 minutes per scheduling interaction, 5–10 times/week → 10–50 minutes/week.
• Candidate 2 (Admin): receipt logging. Replace manual copy/paste with a one-tap shortcut that extracts amount + vendor and records to a sheet. Typical save: 1–2 minutes per receipt, 5–7 times/week → 5–14 minutes/week.

If our work doesn’t involve meetings, swap Candidate 1 for a daily template (e.g., standup or end-of-day journal)
inserted with one keystroke. If we don’t track expenses, swap Candidate 2 for file renaming and filing.

We assumed X → observed Y → changed to Z We assumed that building a sophisticated scheduling flow (auto-time-zone detection, custom questions) would save more time. We observed that setup time ballooned to 70 minutes and the benefit plateaued after we simply shared a single booking link. We changed to a minimal setup: one default 30-minute link, one text expansion snippet, done in 15 minutes. Savings were the same in practice—because the bottleneck was copy/paste and back-and-forth, not customization.

Let’s set up Candidate 1 in 10–15 minutes Objective: Stop typing bespoke scheduling notes. Use a single link and a snippet.

1. Create one booking link (10 minutes)

• If we already use Google Calendar or Outlook: pick any mainstream scheduler (Calendly, Cal.com, SavvyCal, or Microsoft/Google’s built-in appointment slots).
• Make one 30-minute event type. Availability: weekdays 10:00–16:00. Buffer: 15 minutes. Minimum notice: 12 hours. That prevents surprises.
• Copy the booking link.

2. Create a text expansion (3–5 minutes)

• Mac: use macOS Text Replacements (System Settings > Keyboard > Text) or an app (Alfred, Raycast, aText, TextExpander).
• Windows: PowerToys Keyboard Manager + AutoHotkey, or PhraseExpress.
• iPhone: Settings > General > Keyboard > Text Replacement. Android: Gboard dictionary > Personal dictionary > Add shortcut.
• Define shortcut “/meet” → “Here’s my booking link for a 30‑minute chat: [LINK]. Choose anything that fits. If none does, reply with times and I’ll accommodate.”
• Test it: type /meet in email and chat. It should expand instantly.

3. Optional: auto-append the Zoom/Meet link

• Add location “Google Meet” or “Zoom” in the event type so the system injects it. No more copying.

We can stop here. This alone frees 10–50 minutes/week if we schedule often. The payoff starts on the first reply we send.

Objective: One-tap capture of receipt amount + vendor into a log.

Option A: Mobile shortcut to Google Sheet (iPhone Shortcuts / Android Routines + Google Sheets)

• Create a Google Sheet with columns: Date, Vendor, Amount, Category, Notes.
• iPhone Shortcuts:
  • New Shortcut: “Log Receipt.”
  • Actions:

• Android:
  • Use a simple routine with a Notes app or Tasker: Prompt vendor and amount, then append a line to Google Sheets via IFTTT applet “If Webhook then add row to Spreadsheet.”

Option B: Email-forward receipts to a tracker

• Create a filter for receipts (subject contains “receipt” or “invoice”, from known vendors).
• Use an automation service (Zapier, Make, Power Automate):
  • Trigger: New email matching filter.
  • Action: Extract amount with a simple regex (e.g., currency pattern), add row to Google Sheet.
  • Save original email to a folder “Receipts/Raw.”

Option C: Desktop file watcher for PDFs

• Mac: Hazel rule or a simple Shortcut watching Downloads:
  • If file name contains “invoice” or “receipt” and file kind is PDF → Rename to “YYYY‑MM‑DD_[Vendor].pdf” → Move to “Documents/Receipts/2025.”
  • Optional: Trigger a script to add a row with file name and date to a CSV.
• Windows: Power Automate for Desktop:
  • Monitor Downloads. On file create matching keywords → Move and rename → Append to Excel table.

Start with Option A if we have a phone. It works anywhere, even offline, and it creates the habit of immediate capture. It typically saves ~90 seconds per receipt by removing later search and transcribe.

• Both happen often (≥5/week).
• Both are easy to prove with a stopwatch.
• Both cut friction and prevent small errors (missed links, lost receipts).

• A booking link that took 15 minutes to set may save 30–60 minutes in week one. Clear win.
• A file renamer that takes 60 minutes to design may save only 5 minutes this week. Not for today.

We choose minimum viable automation. Today’s limit: 30 minutes total setup. If we cross it, we cut features.

Measurement keeps us honest. We’ll take two 24-hour samples: before and after.

1. Baseline (today before setup if possible, or tomorrow morning):

• Start a timer when we respond to a scheduling request. Stop when the message is sent. Record: 3:40, 2:15, 4:05.
• Time one receipt logging the old way: 1:35.
• We only need 3–5 samples per task.

2. After setup (tomorrow through next week):

• Time the /meet expansion and send: 0:18, 0:22, 0:14.
• Time the receipt shortcut: 0:28, 0:41.

3. Compute deltas:

• Scheduling: average dropped from 3:20 to 0:20 → save ~3 minutes per occurrence.
• Receipts: average dropped from 1:35 to 0:35 → save ~1 minute per occurrence.

4. Weekly projection:

• If we do 8 scheduling messages and 6 receipts/week: 8 × 3 + 6 × 1 = 30 minutes/week saved.

• Setup time: 25 minutes total.
• Weekly saved: 30 minutes.
• Break-even: 25 / 30 ≈ 0.83 weeks. We are “in the green” by day 5–6.

We often overfit a rule and then reality hits.

• We assumed: Hazel/Power Automate could rename every “invoice” file safely.
• We observed: Vendor names vary; files titled “invoice from John” got misfiled.
• We changed: We constrained the rule to known senders only and left others for manual review. False positives dropped to zero; savings stayed strong.

• Privacy: Booking links expose time slots. We limit availability windows and avoid revealing all-day calendars. Use a separate calendar for public booking if needed.
• Compliance: Work email may block filters and third-party integrations. If unsure, start with personal accounts or on-device tools (Shortcuts, Text Replacement).
• Reliability: Cloud automations can pause when tokens expire. We schedule a 2-minute weekly check (Friday 16:30) to run one test event. This catches silent failures.
• Portability: Text expansion on phone and laptop gives the best day-to-day payoff. It is fast, local, and robust.

A concrete walk-through: standing in our day and doing it 08:23 inbox. A request lands: “Can you meet next week?” Our chest tightens because we’re behind. We inhale, type “/meet,” watch it expand, and hit send. Thirty seconds. The relief is small but noticeable—we didn’t tab to the calendar, didn’t compose a polite paragraph. We go straight back to work.

12:08 cafe receipt. We pull out our phone, tap “Log Receipt,” take the photo, type “Pilot Coffee,” type “7.60,” done. Twenty seconds. We will not rummage through email on Sunday night. No future groan.

We stack these small moves and start to understand why tiny automations feel larger than the clock suggests. They remove transitions. They let us stay in the trench of what we were trying to do.

• “Automation is for programmers.” Reality: text expansion and a single booking link require zero coding and 15 minutes total.
• “It takes longer to set up than it saves.” Sometimes, yes—if we automate rare tasks. But for daily loops, break-even often happens within the first week.
• “I need a complete system first.” No. Two independent small automations are better than a fragile grand design.
• “I’ll forget the shortcut.” We won’t, if we choose a natural trigger (typing “/meet” or one home-screen tile). If we do forget, we install a visible cue (pin the shortcut widget near the thumb zone).

• Shared inboxes or strict IT: We may not be allowed to install helpers. We default to on-device tools and personal calendars; if that’s still blocked, use boilerplate templates in Outlook/Gmail without external links.
• Sensitive client data: Don’t push emails to third-party parsers without approval. For receipts, prefer local capture and manual entry to Sheets over auto-forwarding.
• Accessibility: Text expansion helps reduce repetitive strain; on mobile, ensure shortcuts are single-tap with large targets. Voice dictation can trigger “insert snippet” on some platforms.

• What it looks like: A filter catches the wrong emails. A step times out. A phone OS update revokes a permission.
• What we do: Build a “pity plan” into the flow. For example, if the Sheet append fails, create a draft email titled “Receipt Draft” so nothing is lost. Or, if the booking link service is down, keep a pinned note “Three upcoming slots” to paste manually.

We do not rush it today. We let the first automation breathe. By midweek, we scan again:

• Do we send the same daily standup update? Build a template.
• Do we start focus blocks and write task notes? Create a one-tap “Start Focus 30” that starts a timer, switches to Do Not Disturb, and opens today’s notes page.
• Do we file statements? Add a folder rule for PDFs with “Statement.”

We pick whichever happens daily and annoys us by Wednesday. Setup budget: another 20 minutes.

A practical menu to choose from (use what we have; ignore the rest)

• Text expansion: macOS Text Replacement, Windows PhraseExpress, iOS/Android built-in.
• Scheduling: Google Appointment Schedules, Outlook Bookings, Calendly, Cal.com.
• File rules: macOS Hazel or Shortcuts; Windows Power Automate for Desktop.
• Clipboard templates: Alfred, Raycast, Beeftext (Windows), aText.
• Cloud bridges (optional): Zapier, Make, IFTTT, Power Automate (cloud).
• Timers and focus: Toggl Track one-click entries; iOS Focus modes tied to Shortcuts.

We do not need more than two tools to get started. Text expansion + one scheduler or text expansion + Shortcuts covers most of the benefit.

• 3 scheduling replies using /meet: 3 × 2.8 minutes saved ≈ 8.4 minutes
• 2 receipt captures via shortcut: 2 × 1.1 minutes saved ≈ 2.2 minutes
• 1 daily standup template inserted with “/su”: 1 × 1.5 minutes saved ≈ 1.5 minutes
• 1 file auto-filed by rule instead of manual: 1 × 1.2 minutes saved ≈ 1.2 minutes Total saved today ≈ 13.3 minutes

Reflecting on the tally, we notice the largest block came from the one behavior we touch most—the scheduling reply. This is the pattern we want: one high-frequency cut, plus one or two small ones. It prevents us from spending an afternoon on an edge case that saves 20 seconds.

Mini‑App Nudge In Brali LifeOS, add a 7-day “Automation ROI” check-in that asks “How many minutes saved today?” and “Which automation fired at least once?” Keep it as a two-tap entry on your home screen.

• Day 1 (today): Set up /meet and one receipt capture or file rule. Time 3–5 uses. Log minutes saved.
• Day 2–4: Observe. If the snippet feels wrong, adjust the text. If the shortcut is clumsy, remove one step.
• Day 5: Pick the second task (if we started with scheduling, pick standup template or focus block; if we started with receipts, add the text expansion).
• Day 6–7: Summarize totals. Kill anything that broke twice or didn’t trigger at least three times.

• At least 45 minutes saved total across both automations (typical range: 25–90 minutes).
• Fewer context switches felt during the day (subjective, but real).
• One tiny maintenance action added to our weekly review (check tokens, run one test).

The busy-day alternative (≤5 minutes)
If today is chaos, do this:

• Create one text replacement on your phone: Shortcut “/meet” → “Here’s my booking link: [paste link].”
• Test it in one email or message. That’s it. Five minutes or less. Even without the formal booking service, a canned “propose times” snippet (“I’m free Tue 14:00–16:00, Wed 10:00–12:00, Fri 09:00–11:00; what suits you?”) still saves minutes.

We keep snippets polite and short. We avoid making the recipient adapt to us in a way that feels cold. A friendly line softens a link:

• “If none of these times work, reply with a few that do and I’ll accommodate.” This invites reciprocity and avoids power dynamics that can come with automated links.

A short detour: when automation is not the answer Some loops are symptoms, not tasks. If we constantly format data for someone else, the fix may be to align on a standard, not to automate formatting. If we are triaging too many messages, better inbox rules or expectations might yield more than clever scripts. We can still begin with a snippet while we negotiate the root cause.

We hold both truths: small automations buy us oxygen now; structural fixes free us later.

We can hear the quiet voice: “This is overkill for a few minutes.” Two counters help:

• The arithmetic of repetition: 3 minutes × 10/week × 50 working weeks = 1,500 minutes = 25 hours/year.
• The cognitive load angle: each small decision is a context switch. Removing three switches/day can stabilize our mood more than we expect.

If it still feels heavy, we shrink the task: text expansion only. No integrations. Build momentum first.

If we have appetite in week two:

• Template switches: If we type “/meet30” vs “/meet45” pull different links.
• Smart receipt categories: Add a menu to shortcut (“Food,” “Transport,” “Work”) to tag the entry.
• Inline variables: In TextExpander or Alfred, prompt for “Project:” and inject into the message.
• Auto-attach your standard agenda doc when creating invitations.

We keep each stretch to 10 minutes. If it spills over, we stop.

Every end-of-day, we make one entry:

• Count of automated events (e.g., “/meet used: 3,” “Receipt shortcut: 2”).
• Minutes saved estimate (rounded).
• Notes: one sentence on friction (“Shortcut failed on poor Wi‑Fi; try local CSV”).

Over a week, a simple chart emerges. The point is not scientific precision; it is to step past vague feelings and see a shape.

• Trigger: what starts the automation (typing “/meet,” file arrives in Downloads).
• Action: what happens (insert text, move file, append a row).
• Scope: the narrow set of cases we support (only PDF receipts from known senders).
• Fallback: what happens if it fails (draft email, manual template).

We notice, by Thursday, a little exhale when a scheduling email appears. We don’t bargain with ourselves; we fire the snippet. That tiny reduction in dread acts like a wedge. It opens space for the next good behavior—like starting a focus block without checking news. Minutes saved are the measurable part. Emotional friction removed is the multiplier.

We worked with a researcher who refused calendar links on principle—felt too impersonal. We proposed a compromise: a snippet that offered the link but warmly invited alternatives. She kept control of tone, lost none of the human gesture, and saved 40 minutes that week. A month later she reported a quieter morning brain, which was the real win she wanted.

• Vendor lock-in: If our whole system lives in a paid tool, we may feel stuck. Keep core snippets in platform-native text replacement; keep data in CSV or Sheets.
• Silent errors: Parsing amounts from emails can be wrong. Prefer human prompts for money, or limit parsing to vendors with consistent formats.
• Over-automation: If we no longer see receipts at all, we may miss fraud. Keep a weekly 5-minute scan of the Sheet for outliers.

If we are new to any of this, we anchor on two things:

• The first automation is allowed to be boring.
• The only success condition is use: did it fire three times this week?

Check‑in Block

• Daily (3 Qs)

  1. Which automation fired today? (list)
  2. How many minutes did it save today (rounded)?
  3. Any friction or failure? (what happened, 1 sentence)

• Weekly (3 Qs)

  1. Total minutes saved this week (sum of daily).
  2. Which automation contributed most? (pick one)
  3. Keep, tweak, or kill? (one verb + why)

• Metrics

  • Count: number of automation triggers per day (integer).
  • Minutes: estimated minutes saved per day (integer).

Closing the loop: one explicit pivot to make after week one We look at the numbers Saturday morning. If one automation fired fewer than three times, we do not “optimize.” We kill it or swap it. If one delivered 80% of the savings, we consider a small extension to that one (e.g., add “/meet45”). We also add one protection against failure (e.g., weekly test, toast notification on success).

Then we carry on. We do not build a cathedral; we stack small stones.