If you have ever asked "why is this approval taking three weeks?", you already know the answer is rarely the approver is lazy. It is almost always the process around the approver: the request landed in the wrong place, the right person never saw it, the context was missing, or nobody owned the next step.
Approvals get slow for a handful of recurring, fixable reasons. Below are the eight most common ones, what each looks like in practice, and the concrete change that gets things moving again.
1. Approvers do not know they have something to do
The most common cause is also the most invisible. A request gets submitted, it lands in a spreadsheet or a shared inbox, and nothing tells the approver it is their turn. They are not stalling; they have no idea the ball is in their court.
What it looks like: Requests sit untouched for days. When you ask the approver, they say "oh, I didn't see that one."
The fix: Treat notification as a first-class part of the process. Every time a request lands with a new approver, that approver should get a direct, actionable alert (email, in-app, Slack, whatever they actually read) with a link straight to the decision they need to make. Status changes that affect no one do not need notifications. Status changes that hand work to someone always do.
2. One person is the only path forward
A single named approver is the most fragile design in any process. They go on vacation. They get pulled into a project. They get sick. The whole queue stops because routing depends on one human.
What it looks like: The team Slack channel fills with "anyone know when Sarah is back?" Approvals cluster around the same person's return-to-office day.
The fix: Wherever possible, assign to a team queue rather than an individual. Anyone on the team can claim and complete the task. For approvals that genuinely need a specific role (CFO, Head of Legal), pair them with an escalation path: if no decision in N days, the request automatically routes to a backup approver or up the chain.
3. Everything follows the same path
Many processes treat a $200 software purchase the same as a $200,000 capital expense. Both go through the same five reviewers because that is the path the workflow knows. The result: small requests get bogged down in approvals they never needed, and reviewers stop reading carefully because most of what crosses their desk does not matter.
What it looks like: Approvers rubber-stamp 90% of requests. When a real one comes through, it slips by without proper scrutiny.
The fix: Add conditional routing. Low-risk, low-value requests should auto-approve or skip ahead. High-risk requests should pull in additional reviewers automatically. The condition lives in the workflow, not in a policy doc that no one reads, so the routing changes based on the data in the request itself (amount, category, region, vendor risk score, etc.).
4. Approvers cannot find the context to decide
A reviewer opens a request and sees a name and a number. To make a decision, they need the original quote, the vendor's compliance status, last year's budget, and whether the requester has approval authority. None of it is in the request; it lives in three different systems and two email threads.
What it looks like: Approvers send messages asking for more information. The requester scrambles to assemble it. By the time the context lands, the approver has moved on to something else.
The fix: Front-load context capture in the intake form. Make the submitter provide everything the approver will need, using structured fields with validation, not free-text "please describe." For data that lives in other systems, pull it into the request automatically (lookups, API calls) so the approver sees one consolidated view.
5. The process is stitched together from manual handoffs
Submission happens in a Google Form. Tracking happens in a spreadsheet. Notifications happen in email. Decisions happen in Slack. Audit lives in someone's memory. Each handoff between tools is a place where work falls on the floor.
What it looks like: "I thought you were going to email finance." Requests get duplicated, lost, or stuck between systems with no one accountable for the gap.
The fix: Collapse the moving parts into a single system of record where the request, the form data, the routing, the notifications, and the decisions all live together. A purpose-built workflow tool does this; a spreadsheet does not.
6. "Stuck" is invisible: there are no SLAs or escalations
Without explicit time limits, every request looks the same to the system: pending. A request that landed yesterday and a request that landed three weeks ago show up the same way in the queue, so nothing surfaces the ones that are actually stalled.
What it looks like: People only find out a request is stuck when the requester complains. Management has no way to spot patterns ("legal review always takes 11 days") without manual analysis.
The fix: Set stage-level SLAs: a target time for each step. When a stage exceeds its SLA, the system flags it, notifies the assignee again, and (after a configurable window) escalates automatically. Stuck work surfaces itself instead of waiting to be discovered.
7. The status field does not tell you anything
"In progress" is not a status. It is the absence of one. When the queue says "12 requests in progress," nobody knows which are waiting on legal, which on finance, which on the submitter to upload a missing document, and which are genuinely stalled.
What it looks like: Daily standups spend twenty minutes asking "where is each of these right now?" Status meetings exist purely to translate vague statuses into actual state.
The fix: Make status reflect the current stage and current assignee, not a generic lifecycle state. A request should say "Awaiting legal review, assigned to Compliance team, 2 days in stage", not "Pending." If you cannot describe the state in one sentence without context, the status is broken.
8. There is no audit trail, so every retro starts from zero
When something goes wrong (a wrongful approval, a missed control, a contract that should never have been signed), the investigation begins with "who approved this?" If the answer is buried in email threads and changed spreadsheet cells, the retro takes weeks and reaches no clean conclusion.
What it looks like: Compliance reviews are dreaded. Auditors get a stack of screenshots. Patterns of repeat problems go unnoticed because nobody can analyze decisions in aggregate.
The fix: Capture every action with an actor and a timestamp, automatically, as part of the workflow. Who submitted, who reviewed, what they saw, what they decided, when they decided it, and what changed in the data along the way. Audit becomes a query, not an excavation.
Diagnosing your own process
If approvals in your organization feel slow, the cause is almost certainly more than one of the above acting together, usually a stack of three or four. A quick diagnostic:
- Open your longest-running open request. Where exactly is it stuck, and who knows it is stuck?
- Pick any approver and ask: "How do you find out you have something to do?" If the answer is "I check the spreadsheet" or "someone emails me," you have a notification problem.
- Look at your last 20 approvals. Did they all take the same path? If yes, you are missing conditional routing, and you are probably over-reviewing low-risk work.
- Ask any reviewer how long it takes them to gather the context for a decision. If the answer is more than a minute, your intake is incomplete.
You do not need to fix all eight at once. Most teams get an outsized return from the first two (direct notifications and team-queue assignments) because those alone eliminate the majority of "the request just sat there" delays. Conditional routing and front-loaded context come next. The rest compound over time.
The good news: none of these problems require working harder or hiring more people. They require designing the process so the work routes itself, surfaces itself when it stalls, and records itself as it goes.