How Remote Teams Actually Use Digital To Do Lists That Work

1. Shared task lists that do not refresh in real time

The first time we rolled out a shared Google Tasks list inside Google Chat Spaces, we thought we’d solved it. Everything was editable, everyone could see it, and it sat right where the team already communicated. But about two weeks in, something kept happening: people were marking tasks complete from mobile, and somehow those changes weren’t showing up for others using desktop. We didn’t notice until someone asked why two people were still working on the same backlog task that had been done three days ago.

This actually comes down to how Google Tasks syncs across platforms — the mobile app caches activity independently of web, and if Chat + Tasks is open in another tab, it won’t always force a sync unless something actively changes visually. You can trigger it by switching from list A to list B and back, which is an absolutely wild workaround no one should have to do.

So now we push updates into a Notion database and only link those items back as URLs. Yeah, it’s clunky, but at least everyone’s always looking at up-to-date status. Google’s integration just doesn’t handle multi-location sync gracefully when it’s embedded across Gmail, Chat, and Calendar. Classic silent race condition.

2. Recurring tasks duplicating unexpectedly during weekly resets

TickTick was our guilty pleasure until recurring work items started cloning themselves like some kind of infinite respawn. We’d set a task like “Monthly invoicing script check” to recur on the 1st of the month. But when someone ticked it off early (say, the 29th), it duplicated — one version for the 1st, and one that stubbornly thought it was due now.

This isn’t unique to TickTick. Todoist too has weird behavior with every X days tasks vs. every month. The difference isn’t in frequency — it’s that “every X days” starts computing from date marked complete, not scheduled date. That alone broke several handoff flows until we explicitly rewrote each workflow to schedule-from-set-date-not-complete.

Our current system uses a Make.com scenario to reset master tasks via webhook calls. That system grabs the original task by ID, not name — and updates status + assignee once a month. A hidden gotcha: inserting a single emoji in the task name broke the ID matcher when passed through a JSON sanitizer in Make. Wild stuff.

3. Zapier filters that silently fail when working with nested checklists

When we tried using a Zapier automation to update Airtable from checklist items inside ClickUp, we ran into something maddening: sometimes the Zap just didn’t run. No flags, no errors — just… skipped.

The problem was ClickUp’s structure. Subtasks inside tasks are sometimes passed as nested objects, other times not — depending on how they were created. A checklist built through an iOS widget embedded it one way; a web-created checklist nested it differently. The filter step looking for checklist_item_name contains "Review" silently failed all entries that didn’t match the correct internal object shape.

Aha moment: We debugged it with Zapier’s task history, opened the raw input/output, and found that when created via mobile, checklists lived under task.content.blocks[2].details instead of task.checklist. No amount of filter fiddling will help if you don’t flatten these properly first — we eventually used a Code step in Python to normalize the incoming payload. Why isn’t this documented? No clue.

4. Task comments as source of truth that no one sees

We used Asana comments as running logs for weekly planning. One person would drop a bunch of notes, toss in the Zoom planning link, add a meeting doc. But six months in, we realized nobody was checking comments unless they were mentioned directly. Every single update was effectively invisible to the team unless someone responded in-line. Doesn’t matter how good your process is if nobody looks in the right pane.

We fixed it through Notion. Each week’s meeting summary starts with a synced block that embeds the comments via link + context sections — thanks to the Zapier + Notion integration. But here’s the kicker: Asana’s API doesn’t pass rich comment threading. The replies collapse into plaintext, so hierarchies die unless you post each reply as a new db row. Which makes readability a mess unless you also track comment ID as a thread key.

That’s how we ended up parsing comments into individual lines, then grouping by the first bolded name tag to simulate threading post-facto. Insane workaround — but easier than trying to teach ten people to change reading habits overnight.

5. Notion rollups creating ghost tasks you cannot delete

I love Notion but it has a deeply cursed behavior around linked databases with rollups. We connected our weekly “Workload” board to a “Deliverables” database using status-based rollups. But when someone archived a task via another synced view (e.g. a calendar layout), the main board would sometimes still show the item as if it were active.

The worst part: It wasn’t clickable. You couldn’t open the ghost task. It just showed up as a grey entry with metadata but no access. Turns out it had been soft-deleted in the system but still existed in the target filter range based on cache. The only fix was to refresh the board view after toggling the filter off and on — a hard visibility reset which flushed the ghost.

Once we figured that out, we added a dashboard switcher that intentionally clears every filter one by one and re-applies them on button press using linked pages + templates. No, not elegant. But it’s repeatable, and it crawls fewer bugs than trusting the rollups will clean themselves up.

6. Slack message reminders as makeshift task managers that scale badly

Slack’s /remind still gets abused by our team even though we’ve tried to move off it. You know the type: people set /remind me in 2h to follow up and forget they ever did. Then the DMs pile into notification hell, and you lose track of what was a personal reminder, vs a group task, vs a high-priority flag.

We experimented with forwarding these messages into Trello via email-to-board automation — works, but lacks threading context. Then tried using Slack’s new Workflow Builder to route reminders into a proper database — immediately hit a wall. There’s no native way to capture a message being reminded. You can only trigger workflows on new forms or channel messages, not personal /remind posts.

Eventually someone found an unlisted trick: if you start a Slack workflow with a shortcut, and then send a reference to the reminding message (via timestamp), you can anchor that task directly. But it’s fragile — timestamps aren’t stable if the original message is edited after creation. One person updated a typo in their slack post and the linked workflow crashed hard with a “message_not_found” error. So now we snapshot message text as JSON to freeze it regardless of content edits. Fragile. But functional.

7. Central dashboards that fall apart under cross-timezone edits

We had a sleek Airtable dashboard designed to track content production across four contractors — two in Europe, two in North America. At 10AM CET, the board looked fine. By 3PM PST, three of the same tasks were showing as due “yesterday” instead of “tomorrow” — even though the timestamp was still ISO-formatted.

The board relied on calculated date fields using TODAY() and NOW(), which aren’t timezone-aware unless you specifically wrap them with SET_TIMEZONE() inside formula columns. That means if someone’s browser is in a different zone, their view skews how those fields resolve. Airtable doesn’t resolve formulas server-side synchronously — it does it per-client, which is wild given how often people are collaborating in real time.

What fixed it: We moved all calculated dates to backend sync flows. Every hour, a Make.com scenario recalculates status using a fixed UTC offset and stores the result directly in a synced “status text” field. Cost us a few hundred ops per month, but now status flags are consistent regardless of where you open them. Honestly, should’ve done that on day one. Everything else is just guessing.

8. Personal to do lists that derail during team app switching

I’ve used Things, OmniFocus, and Todoist at various points — all gorgeous. But for remote work, syncing personal tasks to team contexts breaks down fast. Let’s say I brain dump Monday tasks into Things. Half of them are async follow-ups from Friday that came via Slack, a few are Google Doc comments, one’s a Notion column note.

None of those platforms naturally pull in external items. So I end up manually copying each one over into Things, tagging them, and breaking them into projects. Except three of those five platforms also have their own task tools — Notion tasks, Slack reminders, Docs actions. If I do all my work there, I forget to tick off Things. If I do it in Things, others have no idea what’s moving.

Here’s the compromise hack I landed on:

• Slack reactions auto-Zap into my Things inbox (via email parser)
• Docs + Gmail comments with @me get logged into a Google Sheet
• Sheet rows update my Notion board via synced checkbox triggers
• Notion weekly tasks embed my Things URL in hidden metadata
• Each Sunday I just sort by undone + stale and roll them forward

It’s crisp when it works. But if I forget Step 2 for even a day, the whole bridge collapses and I end up triple-tracking or duplicating tasks. Which still happens. Often. But less than before.