GTD for Multiple Jobs: Exact System to Separate Contexts, Prioritize, and Execute

GTD for multiple jobs requires three non-negotiable adjustments: (1) separate projects by job (e.g., Client A, Personal Project, Admin) to avoid mental overlap, (2) tag every task with a context (e.g., @office, @calls, @computer) to filter what you can do right now, and (3) define the next physical action for every task (e.g., "open Figma and design login button" instead of "work on app"). Without these, GTD collapses into a bloated to-do list. Here’s how to implement it with precision.

Step 1: Capture Everything—The Zero-Trust Rule

Your brain is a terrible office. Capture every task, idea, or request immediately—no exceptions. For multiple jobs, this means recording items as they arise and assigning them to the correct job. Use a tool that lets you see all tasks at once (to avoid silos) but filter by job when needed. Example workflow:

• Morning email triage: Forward actionable emails to your capture system (e.g., "u-xxxx@in.heyfoco.com" if using Foco’s email capture). Label them with the job (e.g., "Client A") and context (e.g., "@computer").
• Voice capture for ideas: Dictate tasks on the go (e.g., "Call supplier B to confirm delivery—@calls, Admin job"). Tools like Foco transcribe and auto-fill fields (date, priority, recurrence).
• Meeting notes: Record action items during calls (e.g., "Review Client A’s feedback by EOD—@computer, Client A"). Use time-stamped notes to reference later.

Pro tip: If you’re not capturing everything, you’re still relying on memory. Test your system: after a week, check if any task slipped through. If yes, tighten your capture habit.

Step 2: Process Tasks—The 2-Minute Rule and Next Actions

Processing turns chaos into clarity. For each captured item, ask: "Does this require action?" If no, trash it, archive it, or save it as reference. If yes, apply the 2-minute rule: do it immediately if it takes <2 minutes. For longer tasks, define the next physical action—the very next step to move the task forward. Examples:

• Vague task: "Work on marketing campaign" → Next action: "Open Google Docs and draft 3 headline options for Client A’s email."
• Email request: "Need feedback on design" → Next action: "Message [Name] asking for specific feedback on the login button color."
• Recurring task: "Pay supplier invoice" → Next action: "Log into bank and schedule transfer for $1,200 to Supplier B by Friday."

Why this works: When managing multiple jobs, ambiguity is the enemy. A task like "prepare investor pitch" could mean 10 different things. Defining the next action (e.g., "open Keynote and outline slide 1") removes friction. Rule of thumb: If a task lacks a next action, it’s not a task—it’s a project.

Step 3: Organize by Projects, Contexts, and Time

Projects: Group by Job and Outcome

In GTD, a project is any outcome requiring >1 action. For multiple jobs, group projects under job-specific containers. Example:

• Job: Client A (Digital Marketing) → Projects: "Q2 Campaign Launch," "Monthly Analytics Report."
• Job: Personal Project (App Development) → Projects: "MVP Login Flow," "Investor Outreach."
• Job: Admin → Projects: "Quarterly Invoicing," "Contract Renewals."

Key detail: Each project must have at least one next action. If a project stalls, it’s because the next action isn’t defined. Example: The project "Q2 Campaign Launch" might have next actions like "Draft email copy for Client A" (@computer) and "Schedule social media posts" (@office).

Contexts: Filter by Location, Tools, or Energy

Contexts are labels that tell you where or with what you can complete a task. For multiple jobs, they’re critical to avoid context-switching. Use these categories (customize as needed):

• @office: Tasks requiring your workspace (e.g., "Review contracts for Client B").
• @computer: Tasks needing a device (e.g., "Edit video for Client A’s ad").
• @calls: Tasks requiring a phone (e.g., "Call supplier to confirm delivery").
• @home: Personal/admin tasks (e.g., "Pay electricity bill").
• @time-30m: Tasks taking ≤30 minutes (e.g., "Reply to Client A’s feedback email").
• @energy-low: Mechanical tasks (e.g., "Organize invoices in spreadsheet").

Pro tip: Contexts shine during downtime. Stuck in a waiting room? Filter by @calls or @time-30m. At your desk? Filter by @computer and your current job. Avoid: Mixing contexts (e.g., "@office @calls")—it dilutes their power.

Time: Assign Deadlines and Duration

Not all tasks need deadlines, but for multiple jobs, time-blocking prevents overlaps. Example:

• Client A: Block 2 hours on Tuesday for "Draft campaign brief" (due Thursday).
• Personal Project: Block 3 hours on Thursday for "Prototype login flow" (no hard deadline).
• Admin: Block 1 hour on Friday for "Quarterly invoicing" (due EOD).

Why this works: Time-blocking forces you to estimate effort and commit to a schedule. Without it, urgent tasks (e.g., Client A’s request) will cannibalize important ones (e.g., app development). Learn how to avoid double bookings with time-blocking here.

Step 4: Weekly Review—The Non-Negotiable Habit

The weekly review is GTD’s immune system. Without it, your system rots. Dedicate 30–60 minutes every Friday to:

• Review all projects: Ensure each has a next action. If a project has no next action, either define one or archive it.
• Update contexts: Adjust labels based on your upcoming week (e.g., if you’re traveling, add @travel to relevant tasks).
• Purge completed tasks: Archive or delete tasks marked as done. If a task lingers for >2 weeks, ask: Is this still relevant?
• Plan the next week: Assign time blocks to priority tasks. Example: "Monday: 2h for Client A’s feedback; Tuesday: 3h for app prototype."

Pro tip: Use the review to apply Parkinson’s Law. If a task has no deadline, assign one (e.g., "Finish investor pitch by Wednesday"). This prevents procrastination. See how to use Parkinson’s Law for multiple jobs here.

Step 5: Execute—Focus on What Matters Now

GTD’s final step is execution, but with a twist for multiple jobs: you must filter aggressively. Example workflow:

• Morning: Filter by @office and your current job (e.g., "Client A"). Tackle the highest-priority task first.
• Afternoon: Switch to @computer tasks for your personal project. Use time-blocking to avoid overrun.
• Evening: Filter by @home or @energy-low tasks (e.g., admin work).

Key rule: Never work from your master task list. Always filter by job + context + time available. This prevents overwhelm and ensures you’re always working on the right task.

Real Example: GTD for Multiple Jobs in Action

Let’s apply GTD to a freelancer managing three jobs: Client A (marketing), Personal Project (app), and Admin. Here’s how their week unfolds:

Monday: Capture and Process

• Capture: Emails from Client A, app ideas, pending invoices, and a meeting with an investor.
• Process: Define next actions: "Draft brief for Client A’s campaign—@computer, Client A," "Research Firebase for app login—@computer, Personal Project," "Schedule $1,200 transfer to Supplier B—@home, Admin."
• Organize: Assign each task to its project and context. Time-block: "Tuesday 10 AM–12 PM: Draft brief."

Tuesday: Focus on Client A

• Filter: View only Client A tasks with @computer context.
• Execute: Spend 2 hours drafting the brief. Send it to Client A.
• Downtime: Use 15 minutes to call Supplier B (@calls) and confirm the invoice.

Wednesday: Review and Adjust

• Review: Client A replies to the brief. Add next action: "Review feedback and revise—@computer, Client A."
• Update contexts: Working from home today, so add @home to admin tasks.
• Purge: Delete "Schedule transfer to Supplier B" (completed).

Thursday: Time-Block for Personal Project

• Filter: View only Personal Project tasks with @computer context.
• Execute: Spend 3 hours researching Firebase and prototyping the login flow.
• Downtime: Email the investor (@computer) to prepare for Friday’s meeting.

Friday: Weekly Review

• Review projects: Ensure each has a next action. Archive completed tasks.
• Plan next week: Time-block Monday for Client A’s feedback and Tuesday for app development.
• Adjust contexts: Add @travel for next week’s client visit.

Common Mistakes (and How to Fix Them)

• Mistake 1: Mixing projects in one list. Fix: Use a tool that lets you group by job (e.g., Foco’s color-coded jobs) but still see all tasks in one view. See how to separate contexts without losing the big picture here.
• Mistake 2: Not defining next actions. Fix: Break every task into a physical action (e.g., "open Trello and add due date" instead of "organize tasks").
• Mistake 3: Ignoring contexts. Fix: Tag every task with a context (e.g., @office, @calls) and filter by it during execution.
• Mistake 4: Skipping the weekly review. Fix: Block 30–60 minutes every Friday. Treat it like a client meeting—non-negotiable.
• Mistake 5: Overloading the next actions list. Fix: Keep only tasks you can do in the next 3–5 days. Archive the rest.

How to Apply GTD for Multiple Jobs with Foco

GTD for multiple jobs demands a tool that separates contexts without siloing information. Foco’s design aligns with GTD’s core principles:

• Jobs as containers: Create a job for each responsibility (e.g., "Client A," "Personal Project," "Admin"). Each job has a color, so tasks are instantly recognizable in Panorama mode (all jobs) or Focus mode (one job).
• Contexts as tags: Use Foco’s unlimited tags to label tasks (e.g., @office, @calls, @computer). Filter by tag to see only relevant tasks.
• Next actions via time-blocking: Assign a realization date (when you’ll work on the task) and duration (e.g., 2 hours). View tasks in the calendar to avoid overlaps.
• Capture on the go: Use voice capture to dictate tasks (e.g., "Call Client A to confirm meeting—@calls, Client A, priority: urgent"). Foco auto-fills fields (date, priority, recurrence) and attaches the audio.
• Weekly review made easy: Use the Kanban view to drag tasks between columns (e.g., "To Do," "Doing," "Done"). Filter by job or context to focus your review.

For freelancers or teams, Foco’s collaboration features let you invite others to a job and assign tasks without mixing responsibilities. Pro tip: Use email capture (u-xxxx@in.heyfoco.com) to turn actionable emails into tasks with the email attached as a note. This keeps your inbox clean and your GTD system intact.

FAQ

Can I use GTD for multiple jobs if I’m not a freelancer?

Yes. GTD works for anyone juggling multiple responsibilities (e.g., a full-time employee with side projects, a parent managing work and family). The key is to separate jobs into distinct containers (e.g., "Work," "Side Hustle," "Personal") and apply contexts to filter tasks.

How do I handle tasks that belong to multiple jobs?

Assign the task to one primary job and use tags to link it to others. Example: A task like "Update website for Client A and Personal Project" could belong to "Client A" with a tag #PersonalProject. This keeps your system clean while preserving connections.

What’s the best way to prioritize tasks across multiple jobs?

Use the Critical Power List method: (1) Identify tasks that are time-sensitive (due today/tomorrow), (2) high-impact (e.g., client deliverables, investor meetings), and (3) blockers (tasks that prevent others from moving forward). See the exact steps here.

How do I avoid context-switching when using GTD for multiple jobs?

Batch tasks by context and job. Example: Dedicate mornings to Client A tasks with @computer context, afternoons to Personal Project tasks with @office context, and evenings to Admin tasks with @home context. Use time-blocking to enforce these boundaries.

Can I use GTD with tools like Notion or Asana?

Yes, but GTD for multiple jobs works best with a tool that unifies tasks from all sources without forcing you to migrate data. Foco’s Plus plan connects to Notion, Asana, GitHub, and others, pulling tasks into one place while keeping the original intact. Learn how to unify tasks without migrating here.