How to Handle Tasks That Depend on Other People Without Losing Track of Them

A task can be difficult to manage even when you know exactly what needs to be done. The problem is different when you cannot move forward until someone else does something first.

You may need a document from a colleague, approval from a manager, an answer from a client, a decision from a family member, or information from a service provider. Until that happens, your part of the work may be stuck. If these tasks are kept only in your memory, they are easy to forget. If they stay mixed with your active tasks, they can also make your task list harder to understand.

The solution is to treat these situations as dependency-based tasks. Instead of simply writing down what you want to accomplish, record what is blocking progress, who controls the next action, when you should check back, and what you will do when the response arrives. This creates a simple distinction between work you can do now and work that is waiting on someone else.

What Makes a Task Dependent on Someone Else?

A task has a dependency when you cannot complete the next meaningful step until another person provides something, makes a decision, gives permission, or completes a related action.

For example, “finish the client proposal” sounds like one task. But perhaps you cannot finish it because the client has not confirmed the project budget. In that situation, your actual next step may be waiting for the budget confirmation.

Other common examples include

• Waiting for a colleague to send sales figures before preparing a report.
• Waiting for a manager to approve a purchase.
• Waiting for a client to choose between two project options.
• Waiting for a contractor to confirm a delivery date.
• Waiting for a family member to provide information needed for a booking.
• Waiting for someone to sign or return a document.
• Waiting for another person to complete their part of a shared project.
• Waiting for a reply before changing an account or making a decision.

The important point is that these are not ordinary unfinished tasks. Your ability to proceed depends partly on another person.

Start by Identifying the Dependency

The first step is to stop describing the task as if you are responsible for every part of it.

Suppose you write:

Finish website update—waiting for Sarah

That tells you very little. What are you waiting for? Why do you need it? What happens after Sarah responds?

A more useful record would be

Website update—waiting for Sarah to confirm the new pricing figures. After confirmation, update the pricing page and send it for review.

Now the dependency is clear.

When you identify a waiting task, ask yourself three questions:

1. What exactly am I waiting for?
2. Who needs to provide it or complete the next action?
3. What will I do once I receive it?

If you cannot answer these questions, the task probably needs more detail before you put it on your waiting list.

Record Exactly What You Are Waiting For

“Waiting for information” is usually too vague.

Information can mean a file, number, answer, decision, approval, password, specification, date, confirmation, or something else entirely. The more specific you are, the less mental effort you will need later.

Compare these two notes:

Waiting for Tom

and:

Waiting for Tom to send the final product dimensions for the brochure.

The second version is much easier to act on. When you see it several days later, you immediately know what is missing.

A useful waiting-task description can follow this pattern:

Waiting for [person] to [specific action or item] so I can [next step].

For example:

Waiting for the landlord to confirm the repair date so I can arrange access to the apartment.

Waiting for the client to send the logo files so I can finish the presentation.

Waiting for my brother to confirm the travel dates so I can book the accommodation.

This small amount of context prevents many forgotten tasks.

Make Ownership Clear

A task can involve several people without all of them owning the next action. Imagine a team is preparing a report. You are responsible for writing it, another employee is responsible for collecting figures, and a manager must approve the finished report. If you write “Report—waiting,” ownership is unclear.

Instead, separate the stages:

Waiting for Alex: monthly figures
My next action: add figures to the report.
Then waiting for manager approval

This distinction matters because the person who ultimately benefits from the finished task is not necessarily the person who currently owns the next action. For every dependency, identify the person who can actually unblock you. If nobody clearly owns that action, the real problem may be an ownership issue rather than a simple waiting task.

Give Every Waiting Task a Follow-Up Point

A waiting task should not require you to repeatedly remember, “I need to check on that.”

Record when follow-up makes sense.

For example:

Waiting for the client to approve the homepage design—follow up Thursday.

The date does not always need to be a strict deadline. It can simply be the point when you have decided that checking again is reasonable. The appropriate follow-up point depends on the situation. A coworker who said they would send something this afternoon may need a different follow-up time from a government office that normally takes several business days. The important part is that you make the decision once instead of repeatedly reconsidering it.

You can also record a condition rather than a date:

Follow up two business days after sending the request.

This is useful when the request could be sent on different days.

Keep the Original Context Attached

A waiting task often becomes useless when the original conversation disappears.

Imagine receiving a message saying:

“I’ll check with finance and get back to you.”

Three days later, you remember that you were waiting for something, but you cannot remember which question finance was supposed to answer. Avoid this by keeping enough context with the task.

You do not need to copy an entire conversation. Record the relevant details, such as

Waiting for Maria to confirm whether the subscription can be cancelled without a fee. Asked by email Monday. If confirmed, cancel the account.

If the task relates to a particular email, document, message, or project, keep the relevant reference nearby. The goal is to make the task understandable when you return to it later without searching through your memory first.

Separate Waiting From Active Work

One of the most useful changes is to stop treating blocked tasks as if they were tasks you can work on right now.

Your active work might include:

• Draft the introduction.
• Review the spreadsheet.
• Call the supplier.
• Prepare the presentation.

Your waiting work might include:

• Waiting for supplier delivery confirmation.
• Waiting for client approval.
• Waiting for the final spreadsheet from finance.

These are different states.

If you mix them together, your task list can make it appear that you have more actionable work than you really do. A waiting task may sit there for several days even though there is nothing useful you can currently do.

A separate waiting For a section is often enough to solve this problem. It does not have to be a complicated system or a special productivity application. A simple list, note, or task section can work as long as the information is clear. The important thing is that your active list answers, “What can I work on now?” while your waiting list answers, “What am I expecting from someone else?”

Do Not Follow Up Just Because You Remember

One reason dependency-based tasks become stressful is unnecessary checking. You remember that someone has not replied, so you open your messages. You check your email again later. Then you wonder whether you should send another message. A few hours later, you check again. This creates activity without moving the task forward. Instead, decide the follow-up point when you create the waiting task.

For example:

Waiting for the supplier to confirm the delivery date. Follow up Wednesday morning if no response.

Until Wednesday, you do not need to repeatedly reconsider the issue. There are exceptions. If the missing response suddenly becomes urgent because of a deadline or changed circumstances, you can act sooner. But for normal situations, a planned follow-up reduces unnecessary checking.

Decide What Happens When Someone Does Not Respond

A follow-up is not always enough. Sometimes people forget, miss messages, become unavailable, or cannot provide what you need. Your waiting task should eventually lead to a decision.

After following up, you might:

• Send a clearer request.
• Contact another person.
• Use an alternative source of information.
• Continue with an assumption that can be safely changed later.
• Change the deadline.
• Choose another solution.
• Escalate the issue to the appropriate person.
• Cancel the dependent task if it is no longer necessary.

For example, suppose you need a client’s approval before publishing a webpage. You send the design on Monday and plan to follow up Thursday. If there is still no response, your next step might be another message asking for approval by a specific date. If the client remains unavailable, you may need to contact another project contact or move the publication date. The key is to avoid an endless state of “waiting.”

Know When to Escalate

Escalation does not necessarily mean making a problem bigger. It means changing who or what you rely on when the current dependency is preventing reasonable progress.

Consider escalation when:

• The agreed response time has passed.
• A deadline is approaching.
• You have already followed up without receiving an answer.
• The person responsible is unavailable.
• The missing decision affects other people.
• Continuing to wait creates significant cost or delay.
• You have no clear owner for the next action.

Before escalating, check whether the original request was clear. Sometimes a person has not responded because the request did not explain exactly what is needed.

A useful escalation message is usually specific:

“We need confirmation of the delivery date before Thursday’s installation. Could you confirm the date by Wednesday, or let me know who else can provide it?”

This is more useful than simply saying, “Any update?”

Handle Tasks With Multiple Dependencies

Some tasks depend on several people.

For example, a freelancer preparing a website launch might need:

1. The client to approve the design.
2. The client to provide final images.
3. The developer to complete a technical change.
4. The client to confirm the final text.

Treating all four as one waiting task makes it difficult to see what is actually blocking progress.

Break the dependencies apart.

Waiting for client: final images
Waiting for client: text confirmation
Waiting for developer: technical change
My next action: publish once required items are complete

This makes partial progress visible. If the client sends the images but not the text, you know exactly what remains. It also prevents one completed dependency from being overlooked because the overall task is still unfinished.

Use the System in Everyday Situations

Dependency tracking is not limited to office projects.

At Work

You are preparing a monthly report but need figures from another department.

Waiting for: Finance to send March figures
Needed for: revenue section of report
Follow up: Tuesday
Next action: update report and submit for review

As a Freelancer

A client has not chosen between two design options.

Waiting for: client to select Option A or B
Needed for: final design work
Follow up: Friday
Next action: complete selected design

At Home

You need to arrange a repair, but another family member has the appliance details.

Waiting for: appliance model number from brother
Needed for: book correct repair service
Follow up: tomorrow evening
Next action: contact repair company

For a Personal Project

You are building a small website and need a domain transfer code from the previous owner.

Waiting for: transfer authorization code
Needed for: move domain to new account
Follow up: two business days after request
Next action: start transfer

For Everyday Digital Tasks

You cannot finish updating an account because the service provider must confirm a change.

Waiting for: provider’s confirmation email
Needed for: verify the account change
Follow up: Thursday
Next action: check confirmation and complete account setup

The same structure works because the underlying problem is the same: your next useful action belongs to someone else.

Common Mistakes That Make Waiting Tasks Disappear

A few habits cause most dependency problems.

1. Writing “Waiting for John”

This does not tell you what John needs to provide. Write the specific item or action instead.

2. Relying on Memory

You may remember that you are waiting for someone, but forget why. Record the dependency as soon as you send the request or realize that progress is blocked.

3. Putting Every Waiting Task Into One Undifferentiated List

A waiting item that needs attention today is different from one that can remain untouched for two weeks. Include a follow-up date or condition so the list has useful timing information.

4. Following Up Too Early

Repeatedly checking does not make someone respond faster. Decide when a follow-up is appropriate and leave the task alone until then unless circumstances change.

5. Forgetting Why You Needed the Information

When the response finally arrives, you may have to reconstruct the original problem. Record the next action along with the dependency.

6. Treating a Blocked Task as Active Work

If you cannot make meaningful progress until someone responds, do not let the task occupy the same mental space as work you can actually perform.

7. Failing to Close the Task

Receiving the missing information does not always mean the work is complete. Remove the waiting status, record the new next action, and move the task back into active work if something remains.

This last step is easy to overlook. A person may send the document you requested, but the task can remain forgotten in a “Waiting” list even though you can now continue.

A Simple Dependency Record You Can Start Using Today

You do not need a complicated workflow to begin.

For every blocked task, record these six pieces of information:

• Task: What are you ultimately trying to complete?
• Waiting for: What exact thing is missing?
• Owner: Who controls the next action?
• Requested: When did you ask for it?
• Follow up: When should you check again?
• Next action: What will you do once the dependency is resolved?

For example:

Task: Finish client invoice
Waiting for: Confirmation of the final project hours
Owner: Client
Requested: October 5
Follow up: October 7
Next action: Update hours and send invoice

That is enough to turn a vague reminder into an actionable record.

Close the Loop When the Dependency Is Resolved

When the person responds, take a moment to update the task rather than simply removing it from your waiting list.

• If the information solves the problem, complete the next action.
• If the response creates another dependency, record the new one.
• If the person cannot provide what you requested, decide on an alternative.
• If the task is no longer needed, close it.

The goal is not to maintain a perfect list of everything that has ever been requested. The goal is to make sure nothing important disappears simply because its next step temporarily belongs to somebody else.

Practical Checklist

Before placing a task in your waiting list, check:

• What exactly am I waiting for?
• Who owns the next action?
• Why do I need it?
• What will I do after I receive it?
• When should I follow up?
• Where is the relevant context or reference?
• Is there anything I can still do without waiting?
• What will I do if there is no response?

When the dependency is resolved, check it again:

• Did I update the task?
• Is there now an active action for me?
• Does another dependency need to be recorded?
• Can the task be closed completely?

A good dependency system does not require you to remember who owes you what. It puts that information somewhere reliable, separates blocked work from work you can actually do, and gives each waiting task a clear point for follow-up.

That small change can make shared work, personal projects, freelance jobs, and everyday responsibilities much easier to manage because a delayed response no longer means a forgotten task.