The Approve button wasn't the hard part.
Imagine someone in a business needs money for an expense. They create a request, but another person needs to review it before anything can happen.
That sounds simple enough. But a few questions quickly come up.
Who should approve the request? Does it need one approval or several? Where does the approver find it? And if the request is rejected, how does the person who raised it know why?
The challenge wasn't just designing an approval action. It was making sure every step around that action made sense.
I approached it as one connected journey:
- Set the rules
- Receive a request
- Review it
- Make a decision
- Keep a record
First, businesses needed a way to define their rules.
Before anyone could approve a request, the business needed to tell Earnipay how its approval process should work.
I designed a workflow creation process where businesses could define the workflow title, description, request type, request kind, and approval stages.
The challenge was deciding how much control to give businesses without making setup unnecessarily complicated.
We could have added more configuration options, but that would have made creating a basic workflow feel like setting up an entire enterprise system.
Instead, I focused on the information needed to make each workflow clear and usable.
The goal was simple: businesses should be able to set up their rules without having to learn a complicated tool first.
A workflow needs to show what happens next.
Some requests only need one person to approve them. Others need to pass through several people before they can move forward.
We used stages to define that sequence.
For each stage, the business could specify its name, the role responsible for approving it, and who could initiate it. A workflow could then move through the required stages until a decision was made.
For example, a request might need approval from an HR manager before it reaches a finance manager.
This made the process easier to understand before a request was even created. Everyone could see how the workflow was meant to work.
It also helped clarify an important distinction:
The workflow defines the rules. The dashboard shows what needs attention.
One sets the process up. The other helps people get the work done.
An approval is only useful if the right person can find it.
Once a workflow was in place, requests needed a clear destination.
I designed the dashboard to give approvers a quick view of what was happening across their requests. They could see request totals, statuses, who initiated each request, and who was responsible for approving it.
More importantly, requests that needed attention were visible without requiring people to dig through the product.
The dashboard wasn't just a place to display numbers. It was where approvers could see what needed their attention and decide what to do next.
That reduced the effort required to keep track of pending work.
Keep the decision simple. Give it enough context.
When an approver opened a request, they needed to understand what was being requested before deciding what to do.
I designed the request view to bring the relevant information and approval progress together, with two clear actions: approve or reject.
But rejection needed more thought.
A requester who sees only “Rejected” is left guessing. Was something missing? Was the amount too high? Did the request go to the wrong person?
So I made the rejection reason a required field.
The approver had to explain why the request was being rejected, and that reason became part of the request history.
It was a small interaction, but it made the outcome more useful for everyone involved. The approver could explain the decision, and the requester could understand what happened without having to chase someone for an answer.
People should be able to understand what happened without asking around.
An approval process doesn't end when someone clicks a button. People may need to check who made the decision, when it happened, or why a request was rejected.
I made the decision history visible as part of the experience.
Each request could show its progress, including when it was created, its current stage, and whether it had been approved or rejected. Decisions included a timestamp, and rejected requests retained the reason given by the approver.
This gave businesses a clearer record of how requests were handled.
Instead of relying on messages or someone's memory, people could return to the request and understand its history.
The goal wasn't to build a complicated audit tool. It was to make the information people needed easy to find.
The person setting the rules has a different job from the person approving a request.
As I worked through the experience, it became clear that the product had two distinct sides.
Configure
A business defines the workflow, selects the request type, and sets up its approval stages.
Execute
A member creates a request, the right approver reviews it, and the decision is recorded.
The two experiences needed to work together, but they shouldn't feel the same.
Someone setting up a workflow needs to think about the process as a whole. Someone approving a request needs to understand one request and make a decision.
Keeping those jobs separate helped me design each experience around what that person needed to do.
More options don't always make a better product.
There were plenty of things we could have added: more configuration, more statuses, and more controls.
But every extra option would ask people to spend more time understanding the system.
I kept coming back to three questions:
- Can a business understand what a workflow is for?
- Can an approver quickly understand what a request needs from them?
- Can everyone involved see what happened after the decision?
These questions helped keep the experience focused.
The aim wasn't to make approvals feel powerful or complicated. It was to make them predictable enough that people could get on with their work.
Every step connects to the next.
The finished experience brought the whole process together:
- 01A business creates a workflow
- 02It defines the request type and approval stages
- 03A member submits a request
- 04The request reaches the appropriate approver
- 05The approver reviews the details
- 06They approve or reject it
- 07The decision, time, and relevant context are recorded
Each step is straightforward on its own. Together, they give a business a consistent way to manage requests.
Average approval time fell from 6 hours to 2.5 hours, according to the project's reported Amplitude outcome.
The dashboard helped approvers see pending work, while clearer decisions and visible history made it easier to understand what happened without repeatedly asking for updates.
The real product was the connection between the screens.
A workflow can look like a handful of screens: create a workflow, view a request, approve or reject it.
But those screens only make sense when they work together.
The workflow defines the rules. The rules determine where requests go. Requests lead to decisions. Decisions create a history that people can return to later.
That connection was where much of the design work happened.
I learned to look beyond the individual screen and ask whether the entire process made sense for everyone involved.
When approvals work well, they don't need much attention. People know what to do, requests move forward, and the record is there when someone needs it.
The goal wasn't to make approvals more complicated. It was to make them easier to trust.
