"I signed that one last Tuesday."
When the owner said this, his phone was still open to the approval screen. The record was there. But purchasing had a different version: from the moment sales submitted that purchase requisition to the moment an order actually went to the supplier, nine days passed. How many of those nine days were spent at the owner's step? Five people in the meeting room, five different memories. The conclusion was "everyone needs to move a bit faster." Three months later, the same meeting happened again.
First, something in the owner's defense: his memory isn't lying. He really did approve it quickly once he saw it, because in his mind an approval is the three seconds it takes to tap the button. He doesn't remember the request sitting in his notification list for three days before he scrolled to it. He doesn't remember asking "why are we switching suppliers on this part?", which sent the request back to sales, sales went to ask the plant, the plant answered the next day, and the request was resubmitted. Nobody counts the time outside those three seconds.
You can't find an approval bottleneck by feel. You can only calculate it from how long the request sits at each step. You really only need three numbers: how long the request waited at each step (sitting on someone's desk untouched), how long it took to actually handle, and how many times it was sent back. Put those three numbers in one table and the stuck step shows itself, and the answer is usually different from what everyone guessed in the meeting. More importantly, you can't get these three numbers without a system, because what you need isn't features, it's timestamps. Approvals on paper, in LINE groups, or passed along verbally have no timestamps by nature. All you'll ever get is "I signed it right away." And in the projects I've handled, once the timestamps were laid out, the longest step was usually the owner. That isn't an attitude problem. It's because every request queues up for him, and his decision criteria are the only thing in the company that has never been written down.
I'm Johnny Yang, Brightstream Technology, Taiwan. I've led implementation teams for seven years, across 252+ projects in 32+ industries. What follows is the measurement method I actually use on site.
1. "Approvals are too slow" is a useless sentence
Whenever a meeting is about "the process being too slow," you will hear three things. Sales says purchasing is slow. Purchasing says the manager never replies. The manager says the requests come in with incomplete information. All three may be true, but together they produce no action, because nobody has numbers.
To make the problem solvable, you only need to break each request into four points in time: when it was submitted, when it reached a given person, when that person acted, and when the next step received it. With those four points, you can calculate three numbers.
| What to measure | What it answers | What happens without it |
|---|---|---|
| Wait time | Whose desk the request sat on untouched, and for how long | Everyone blames everyone else and the argument never ends |
| Handling time | How long was actually spent reading, checking and asking | You assume people aren't trying, when the real issue is missing information |
| Rejections | How many times the same request was sent back and redone | A form design problem gets treated as an execution problem |
Of these three numbers, wait time is almost always the main character. The time actually spent "handling" is usually a small slice of the whole process. The rest is queueing. And queueing is the easiest kind of time to fix, because it doesn't require anyone to get smarter or work harder. You just need to send the request to the right place, or not send it at all. As for rejections, a request sent back twice doesn't cost twice the time. It costs twice the time plus two more trips through the queue.
2. You can't get this number without a system
At this point some owner usually says: then I'll have my assistant put together the stats. Fine, but know what you'll run into first.
The first problem is that the data doesn't exist. Paper approvals have a signature but no time. Even if there's a date, it's "the day he signed," not "the day the request reached him." LINE groups are worse. The messages have timestamps, but the discussion about a single request is scattered across three groups and two private chats, and piecing it together costs more work than it saves. And the sales support staff still have that Excel file open, with a status column updated by hand.
The second problem is harder: memory automatically favors the person remembering. Ask everyone to go back and fill in "when did you receive this request," and what you get back will be flattering. Not because anyone wants to fake it, but because people genuinely only remember the moment they acted. Change your process based on data built from memory, and you'll fix the wrong step.
So approvals are one of the few problems you really can't measure without a system. That sounds like a sales pitch, so let me add something more important: it doesn't mean you should go buy a full approval module right now. The lowest-cost version is to pick one type of request, use one shared spreadsheet, require an entry at each of the four points in time, and keep it up for two weeks. Two weeks of manual data is enough to see where things get stuck, and enough to decide whether a system is worth it. But be prepared: manual logging won't last a month, because it runs on discipline, and discipline gets dropped on the first busy day.
The same goes for implementation order. Don't move purchasing, leave requests, quotations and expenses onto a system all at once just because approvals are slow. I wrote about this in "Less is more: doing less is the right call during implementation": move one type of request at a time, and add the second once the first runs smoothly. Companies that launch four at once usually abandon all four halfway, and everyone goes back to LINE.
3. In most companies, the bottleneck is the owner
Once the timestamps are laid out, a lot of owners see something they don't want to see: the step with the longest wait time is them.
To be clear, this isn't laziness or irresponsibility. When the owner's step clogs up, it's usually three causes stacked together.
The first is that no thresholds have been set, so every request goes through him. When one person has dozens of requests to look at every day, the order inevitably becomes "whoever pushes hardest goes first." In that state, speed depends on who's loudest, not on how much the matter matters.
The second is the most common and the most often misread: the owner isn't stuck because he doesn't want to sign. He's stuck because the request doesn't include what he needs to decide. He wants to know whether this customer still has overdue payments, whether switching this part will affect existing orders, which margin line this discount cuts into. None of that is on the request, so he has to go back and ask, and every question is another round. In the data, this shows up as "the owner held it for three days." On the ground, it's a form design problem. Turn the two or three things he always asks about into required fields, and the time at this step often drops that same week. This is the highest-return action in this entire post.
The third is that he simply isn't at his desk. The owner is at a customer, on the production line, on a plane. That's normal, not the exception. Any process that says "wait until the boss is back" ties the company's speed to a person who is constantly moving.
Finding out you're the bottleneck doesn't feel good, but it's actually the best answer you could get. Someone else's step means communicating and waiting for them to get used to change. Your own step, you can fix this afternoon.
4. Thresholds and exceptions: approve by conditions, not by person
There's only one way to get the owner out of the bottleneck position: write down "which situations don't need to go through me."
Most people's first instinct is to use amount: anything under a certain figure, decide yourself. Amount is useful, but amount alone misses the point. The same small sum means very different risk if it's office supplies versus switching to an alternative supplier for a critical part number. The same large sum, if it's a routine payment to an existing supplier under contract, really doesn't need judgment. So thresholds need at least two layers: is this spend within an approved budget or contract, and can it be undone if it's wrong. If it's within budget and reversible, the amount threshold can be set much higher than you'd think. Only tighten it when it's outside budget or irreversible.
The simplest way to set thresholds is to go back through the requests you've signed in the past six months and find the categories where you never changed a word or asked a single question before approving. The type of request you have never sent back is the type you don't need to sign. Your only contribution at that step was making it wait two extra days. This check is brutal, but it usually cuts a sizable share of the volume in one pass.
Once thresholds are set, you have to handle exceptions, and exceptions are what actually decide success or failure. For exceptions to work, you need at least three things. A one-sentence definition of what counts as an exception, not left for employees to guess. A time limit and a delegate, meaning how soon there must be a response, and who takes over when that person is away. And the one most often missed: a default action once the time limit passes. A rule without a default action is no rule at all, because when the deadline hits and nobody responds, people fall back on the old habit of calling the owner. The default action can be conservative. What matters is that it's a decision, not a wait.
There's one more thing that will eat your whole threshold system: rush orders. In many companies, exception handling means someone shouts "rush" and jumps the queue. Do that long enough and rush becomes the norm, and the thresholds are dead. Rush requests must have a cost: state the reason, leave a record, and review where they came from once a month. When people know the number of rush requests they open will be seen, the number drops on its own.
5. "Add one more signature" is always the most expensive fix
After something goes wrong once, the most intuitive reaction is: from now on, this kind of request needs one more person to sign.
The instinct isn't unreasonable. It does make the same mistake less likely to happen again, and it looks free: no money, no system changes, announce it in the group chat and it takes effect the same day. Precisely because it's so cheap, it gets overused. Most of the approval chains that can't move today weren't designed that way. They were patched on, one incident at a time.
But the cost of adding a signature shows up later, and it comes in four layers.
The first layer: wait time doesn't grow linearly. One more step isn't one more person's handling time. It's multiplied by how busy that person is and the odds they're not around. Add three busy people and the request's completion time becomes a gamble.
The second layer is worse: diluted responsibility. The more people sign, the less closely each one reads. On a request with four signatures, usually nobody reads it start to finish, because everyone knows three other people will look at it. On the surface, adding signatures adds three lines of defense. In practice, it often swaps one serious line of defense for four half-hearted ones.
The third layer: it's irreversible. Adding a step takes one sentence. Removing one takes a meeting, and someone has to admit on the spot that their step does nothing, which nobody is willing to do. So approval chains only get longer, never shorter.
The fourth layer: it treats "that one time," not "that type of case." If the cause was an unfilled field or an unchecked condition, adding a person to eyeball it uses your most expensive resource for your most mechanical task. The right move is to turn the check into a rule: if a required field is empty, the request can't be submitted; only values outside a range need a human; everything else goes straight through. People should handle exceptions, not the normal case.
One more idea worth replacing: full sign-off in advance is the most expensive form of auditing. Instead of running every request past three people, let it through, then spot-check a batch each month, and fix the rule when you find a problem. Spot-check cost is fixed. Full sign-off cost grows with business volume. As for which type of request to start with, I covered the same principle in "Which process first? Implementation order decides success or failure": start with the type that has the highest volume and reversible consequences.
6. So what should you do now
Starting next week, do three boring things.
First, pick the type of request people complain about most. Just one. Open a shared spreadsheet and require four timestamps: submitted, reached a given person, that person acted, next step received. Add one more column for the reason it was sent back. Two weeks is enough.
Second, lay out the data, calculate the median wait time for each step, and sort them. The step at the top is your bottleneck. Don't rush to call a review meeting. First, ask that person one question: "When you're stuck, what are you waiting for?" In the projects I've seen, the answer is usually not "I'm busy." It's "I need to ask about something first." That something is the field you should add to the form.
Third, fix that step with two moves: turn the information that always gets asked for into required fields, then cut one layer of approval, starting with the type of request you haven't sent back once in six months. Neither costs money, and neither has to wait for a system.
Don't reverse the order. Measure first, then fix the form, then set thresholds, and only then talk about whether to implement a system. People who do it backwards end up buying a module that moves a slow process online exactly as it was. It runs just as slowly, except this time there's a record proving it.
If you've done one round of measuring and still aren't sure which step to cut, book a free 30-minute diagnostic. I'll go through that approval chain with you, step by step.




