How to use GTD for multiple jobs: structure projects, contexts, and reviews like a pro

Managing multiple jobs or clients at once is a challenge that demands more than good intentions: it requires a system that lets you capture everything demanding your attention, organize it without overwhelming you, and make progress on what matters without losing sight of the details. This is where GTD (Getting Things Done) by David Allen shines. Though GTD was born as a personal system, its flexibility makes it ideal for environments with multiple responsibilities. In this guide, we explain how to use GTD for multiple jobs with concrete examples: from structuring projects and contexts to conducting effective weekly reviews, even when working with tight deadlines and different teams.

Why GTD works for multiple jobs (and what makes it different)

Most productivity methods focus on prioritizing tasks or dividing time into blocks. GTD, however, starts from a radical premise: your mind isn’t made for remembering, but for creating. When managing multiple jobs, mental load multiplies: overlapping deadlines, clients with different expectations, scattered tools, and the constant feeling that something is slipping through the cracks. GTD solves this with a five-step workflow: capture, clarify, organize, reflect, and engage.

What makes GTD unique in environments with multiple jobs is its focus on contexts (where or with what resources you can do a task) and projects (any outcome requiring more than one step). This allows you to filter what you can do at any given moment, regardless of whether it’s for Client A, your personal project, or a household task. For example, if you’re in a meeting with your development team, GTD helps you focus only on tasks requiring that context, temporarily ignoring what you can’t advance there.

Step 1: Capture everything (no exceptions)

The first step in GTD is to empty your mind into an external system. In environments with multiple jobs, this means recording everything: from an urgent email from a client to an idea for a future project or a pending call with your accountant. The key is to use capture buckets (inboxes) separated by type of work or client but centralized in one place. This prevents information from scattering across sticky notes, chats, or unprocessed emails.

Practical example: Capture in action

Imagine you’re a freelance designer with three active clients: a tech startup, a marketing agency, and a personal illustration project. During the day, you receive:

• Startup client: A Slack message requesting logo adjustments (deadline: tomorrow).
• Marketing agency: An email with feedback on a banner (deadline: in 3 days).
• Personal project: An idea for an illustration series (no deadline).
• Home: A reminder to pay the electricity bill (due: today).

In GTD, all of this goes into your capture system, without filtering. The important thing is that nothing stays in your head or in scattered channels. Later, in the clarify step, you’ll decide what to do with each item.

Step 2: Clarify what each thing is (and what it’s not)

Once captured, the next step is to process each item to decide if it’s an action, a project, reference material, or trash. In environments with multiple jobs, this step is critical because it forces you to define what truly requires your attention and what you can delegate, postpone, or ignore. The key question is: Does this require action? If the answer is no, archive it, delete it, or save it as reference. If yes, define the next physical action (e.g., "Call María to confirm the briefing" instead of "Work on Project X").

How to differentiate actions, projects, and references

• Action: A concrete step you can do in under two minutes (e.g., "Reply to Juan’s email with the attached files"). If it takes longer, add it to your next actions list.
• Project: Any outcome requiring more than one step (e.g., "Design the landing page for Client Y" includes actions like "Review briefing," "Create wireframe," and "Send color proposal").
• Reference: Information that doesn’t require action but may be useful later (e.g., the client’s brief, an article on design trends, or server access credentials).
• Trash: Anything that doesn’t add value (e.g., a promotional email or a task you’ve already delegated).

In environments with multiple jobs, it’s easy to confuse projects with actions. For example, "Manage Project Z" isn’t an action—it’s a project. The real action would be "Send the updated timeline to Client Z." Being specific saves time and prevents procrastination.

Step 3: Organize by contexts and projects (the key to staying focused)

After clarifying what each item is, GTD suggests organizing it into context-based lists (where or with what resources you can do it) and projects (to group related actions). In environments with multiple jobs, this structure lets you filter what you can do at any given moment, without mixing responsibilities.

How to define useful contexts for multiple jobs

Classic GTD contexts (like "@computer," "@phone," or "@home") are useful, but in professional environments with multiple clients or teams, you can customize them to reflect key resources, tools, or people. Some examples:

• @client-name: For actions requiring interaction with a specific client (e.g., "@client-startup" for tasks related to that project).
• @tool: For actions dependent on a tool (e.g., "@figma" for design tasks or "@github" for reviewing pull requests).
• @meeting: For actions you can only do in a meeting (e.g., "Approve changes with the marketing team").
• @low-energy: For tasks that don’t require much focus (e.g., "Organize files in Drive").
• @delegated: For actions you’ve assigned to someone else (e.g., "Follow up with the developer on bug #123").

The advantage of contexts is that they let you focus on what you can do now, without getting distracted by tasks requiring a different environment. For example, if you’re at a café with your laptop but no design tools, you can filter your list by "@computer" or "@email" to work on what’s possible.

How to structure projects in GTD

In GTD, a project is any outcome requiring more than one step. In environments with multiple jobs, it’s helpful to group projects by area of responsibility (e.g., "Clients," "Personal Projects," "Administration") and, within each area, by client or type of work. For example:

• Area: Clients
• - Project: "Website redesign for Startup X" (actions: review briefing, create wireframe, send proposal).
• - Project: "Email marketing campaign for Agency Y" (actions: define audience, write copy, schedule send).
• Area: Personal Projects
• - Project: "Launch online portfolio" (actions: select work, write bio, hire hosting).
• Area: Administration
• - Project: "Quarterly invoicing" (actions: review expenses, generate invoices, send to accountant).

Every project should have at least one next action defined. If a project lacks clear actions, it’s a sign it’s stalled or poorly defined. Check if it’s truly a project or if you can archive it as reference.

Step 4: Reflect (the weekly review that keeps everything on track)

The weekly review is the heart of GTD. Without it, the system collapses: lists fill with outdated tasks, projects stall, and mental load returns. In environments with multiple jobs, this review is even more critical because deadlines, priorities, and resources constantly change. The goal is to update your system so it reflects reality and lets you make decisions clearly.

What to include in your weekly review (step by step)

• 1. Empty all your capture buckets: Review notes, emails, messages, and anything you’ve captured during the week. Clarify each item (is it an action, project, reference, or trash?).
• 2. Review your projects list: For each project, ask: What’s the next step? If there’s no clear action, define one or archive the project. Delete completed or irrelevant projects.
• 3. Update your context lists: Review your "@client-name," "@tool," etc., lists. Delete completed actions, update deadlines, and add new actions if needed.
• 4. Review your "Someday/Maybe" list: This list contains ideas or projects that aren’t urgent but might be useful later. Check if any have gained priority or if you can delete them.
• 5. Plan the next week: Based on your updated projects and contexts, define what 3-5 things you want to accomplish next week. It’s not about making an endless list but identifying what will truly move the needle in your jobs.
• 6. Clean your system: Archive old references, delete duplicate tasks, and ensure everything is in its place. A cluttered system causes stress and wastes time.

The weekly review shouldn’t take more than 1-2 hours. If it does, it’s a sign you’re not capturing or clarifying enough during the week. The key is consistency: if you do it every Friday afternoon, for example, you’ll start the next week with clarity and no surprises.

Step 5: Engage (with focus and without distractions)

The final step in GTD is engaging, but not just any way. In environments with multiple jobs, the temptation to jump from one task to another is constant. GTD proposes two rules for choosing what to do at any given moment:

• Context rule: Choose tasks you can do with the resources available now (e.g., if you’re on a train without internet, pick an "@offline" task like reviewing documents).
• Three criteria rule: To decide between options, consider: 1) Context (can I do this now?), 2) Time available (do I have 5 minutes or 2 hours?), 3) Energy (am I fresh or exhausted?).

For example, if you have 30 minutes before a meeting and you’re in the office, you might choose a medium-focus "@computer" task like "Draft the briefing for Client X." If you only have 10 minutes, opt for something quick like "Reply to pending emails." The idea is to align what you do with what you can actually do at that moment.

A productivity system is useless if it doesn’t help you make progress on what matters. GTD isn’t an endless to-do list—it’s a map that guides you toward what truly deserves your attention at any given time.

How to apply GTD for multiple jobs with an app like Foco

While GTD can be implemented with pen and paper, a specialized app makes management much easier when working with multiple clients or projects. Foco is a tool designed for environments with multiple responsibilities, and its structure aligns well with GTD principles. For example:

• Workspaces as areas of responsibility: In Foco, each work (with its name and color) can represent a client, a personal project, or an area like "Administration." This lets you group projects and actions by context, just like in GTD.
• Views to filter by context: With Panorama mode, you see all your tasks from all works, each with its area’s color. If you enter the Focus mode for a specific work, the board filters only tasks for that client or project, equivalent to reviewing your "@client-name" list.
• Customizable fields for actions and projects: Each task in Foco can include due date, priority, tags, and notes, letting you define concrete actions (e.g., "Review briefing @client-startup") and attach references (like the briefing in PDF).
• Weekly review with Kanban and Calendar views: The Kanban view lets you organize tasks by status (e.g., "To do," "Doing," "Done"), ideal for reviewing projects during your weekly review. The Calendar view helps visualize deadlines and sync external events (like client meetings) alongside your tasks.
• Quick capture with voice or email: Foco lets you capture tasks instantly via voice dictation (with automatic transcription) or by forwarding emails to your personal address u-xxxx@in.heyfoco.com. This is useful for emptying your mind on the go without wasting time typing.

The advantage of using an app like Foco for GTD is that you centralize everything in one place, without relying on multiple tools. Plus, its visual design (with colors per work) helps you quickly identify which task belongs to which client or project—key when managing parallel responsibilities. If you already use GTD, Foco can be an ally for keeping the system organized and accessible, especially in environments with tight deadlines and dispersed teams.