Our Remote Team's Async Delivery Workflow, Built on GitHub

A fully remote team spread across six time zones has one hard constraint: at almost any moment, half the team is asleep. The group in this story — a distributed delivery team we’ll call Meridian — built an async delivery workflow on GitHub so that handoffs never wait for a meeting. This is a composite account of how they made progress feel continuous even when the people don’t overlap.

The Async Problem: Handoffs Across Time Zones

Meridian’s earliest attempt at remote work failed in a familiar way. Decisions happened in a daily call that only three of the eight could attend live. Everyone else read a summary hours later, missing context. Work piled up at the boundaries — a tester in one zone couldn’t tell whether a pull request was ready, so they waited for someone to confirm, and that someone was offline.

The team decided that state, not conversation, would drive the work. If the current status of every piece of work was always legible from GitHub, nobody would have to be awake to unblock anyone else.

Workflow States as the Async Source of Truth

Meridian mapped their delivery lifecycle to GitHub labels that KazTrack syncs automatically. The four states became the team’s shared clock:

ready_for_testing → in_progress → passed
                                 ↘ failed

This is the heart of an async delivery workflow: a pull request tells you where it is. A tester waking up in Lisbon doesn’t need to ask anyone what to pick up — they filter for ready_for_testing and start. When they finish, they set passed or failed, the label syncs to GitHub, and a comment posts to the PR. The developer in São Paulo sees the result whenever they come online, with the reasoning attached right on the thread.

No one waits on a meeting to start

Because the state lives on the pull request, the handoff is the label change. There’s no “can someone confirm this is ready?” message sitting unanswered for eight hours. The PR already answers it.

Collaborative Docs Replaced the Standup

Status was solved by labels, but context — the why behind decisions — needed somewhere to live too. Meridian used KazTrack’s real-time collaborative docs for that. These docs supported the async habits they cared about:

• Comments and mentions so a question could be left on a paragraph and answered later by the right person.
• Version history so anyone joining a doc could see how a decision evolved, not just its final state.
• Public read-only share links so they could hand a spec to a client or contractor without granting an account.

A release plan, a test strategy, a “here’s what we decided and why” note — all of it lived in docs that updated in real time and read perfectly well asynchronously. The daily call became optional, then rare.

AI Agents That Respect the Same Boundaries

Meridian leaned on AI to keep the pipeline moving overnight. KazTrack exposes the whole workspace through a built-in MCP server, so agents in Claude Code or any MCP client could participate in the async flow — reading a pull request’s diff, drafting test cases, updating a sprint, or editing a doc. The critical detail for a remote team handing tasks to automation: an agent is always bounded by the token owner’s permissions.

That meant a tester-scoped token could let an agent draft and record test results, but never rewrite roles or touch GitHub credentials. The team could safely leave agents running against work-in-progress while everyone slept, knowing the blast radius matched the permissions of whoever set it up.

A Day in the Life, Across Time Zones

Here’s a representative 24 hours, the async way:

1. Morning, Lisbon. A tester filters for ready_for_testing, claims a PR, starts a timed session, works the attached test cases, and marks it passed. The label syncs; a comment posts to GitHub.
2. Midday, Berlin. A manager reviews the live dashboard, sees what passed overnight, and pulls verified work into a milestone — no meeting required.
3. Evening, São Paulo. A developer reads the comment on their PR, sees exactly why one case failed, and pushes a fix before logging off.
4. Overnight. An MCP-connected agent, scoped to a service token, drafts test cases for newly opened PRs so the next zone wakes up to less manual setup.

At no point did two people need to be online together.

Time Tracking Kept Async Fair

Async work can quietly become invisible work. Meridian used working-time tracking to keep it honest. Sessions rolled up by tester, day, repository, and pull request, so the team could see effort distribution across zones without anyone narrating their day in a status channel. It answered the question every distributed team eventually faces — is the load actually balanced? — with data instead of vibes.

What Made the Async Workflow Hold Together

• State on GitHub, synced automatically. The pull request is the handoff; nobody waits on a human to confirm readiness.
• Docs that read well asynchronously. Comments, mentions, version history, and share links carry context across the offline gap.
• Permission-bounded AI. Agents extend the pipeline overnight without ever exceeding their owner’s access.
• Time tracking for fairness. Effort stays visible without forcing synchronous status updates.

Key takeaways

• An async delivery workflow works when state drives the work, and GitHub-synced labels make state legible to whoever is awake.
• Collaborative docs with comments, history, and share links carry the context that meetings used to provide.
• Permission-bounded AI agents and time tracking keep an overnight pipeline both safe and fair.

If your remote team is still gated by who can make the daily call, the path forward is to let GitHub state and async docs do the coordinating. KazTrack ties workflow labels, collaborative docs, time tracking, and permission-bounded AI into one place — so progress doesn’t have to wait for a shared hour.