Guides / DupreeOps
Design an internal tool around one accountable business action
A practical method for designing internal tools around one accountable action, with research, permissions, evidence design, and a worked example.
A team asks for an internal dashboard to handle refund exceptions. Two weeks later, the draft has tabs for requests, notes, customer history, exports, and reporting. But when you ask a simple question — “What is one person accountable for doing in this tool?” — the room goes quiet.
That is usually the point where internal tools become bloated. The team starts with screens instead of responsibility. As a result, the first release may show data, but it still does not make the core business action easier to perform, easier to review, or easier to control.
A more dependable starting point is to design around one accountable action. In plain terms: one named role receives a trigger, reviews a bounded set of inputs, makes one decision or completes one task, changes a business state, and leaves evidence behind. For a company focused on software, APIs, workflow automation, and internal tooling, that framing fits the stated emphasis on simplifying complex workflows rather than adding software for its own sake (Dupree Ops).
Define the action before you define the interface
An internal tool is easier to scope when its center is a verb phrase instead of a navigation menu.
Strong starting points:
- approve a refund exception
- release a supplier payment batch
- resolve a failed data sync
- verify an account alert
- publish a pricing change
Weak starting points:
- admin portal
- ops dashboard
- back-office app
- internal system rewrite
The useful difference is accountability. A single action lets you describe the workflow with five concrete parts:
| Part | Question | Output |
|---|---|---|
| Actor | Who is responsible for this action? | A named role |
| Trigger | What puts work in front of that role? | An event or condition |
| Input | What information is needed? | Minimum decision packet |
| Outcome | What changes when the action is completed? | A state change |
| Evidence | What proves it happened correctly? | An audit/event record |
This model keeps the team from confusing supporting information with the job itself. Notes, history, exports, and charts may all matter, but only in relation to the main action.
A simple test helps: if you removed every screen except the one needed to complete the accountable action, would the tool still provide business value? If the answer is no, the tool may still be defined as a container for information rather than an operational mechanism.
Use research to discover how the action really works
Teams often describe a process using policy language. Staff usually perform it using workarounds, missing context, and judgment calls. To design a reliable internal tool, you need evidence about the real workflow, not just the official one.
GOV.UK advises teams to plan user research at the start of each development phase and update that plan as they learn more (Plan user research for your service). The same guidance recommends turning assumptions into research questions and choosing activities that give dependable evidence without unnecessary time and effort (Plan user research for your service).
For internal tools, that usually means starting with a small round of interviews and case walkthroughs.
GOV.UK’s interview guidance says in-depth interviews are typically run one participant at a time, though pairs or small groups can work when people perform tasks together (Using in-depth interviews). It also recommends asking open, neutral questions and grounding the conversation in real stories rather than abstract opinions (Using in-depth interviews).
A compact research plan can look like this:
- Write down the current assumption.
Example: “Approvals are slow because reviewers have to look in too many places.”
- Convert that assumption into research questions.
Example: “What information does the reviewer check first?” “What makes a case risky?” “What blocks a decision?”
- Interview current users with recent cases in mind.
Ask for the last case they handled, not an idealized description.
- Record trigger, input, decision, outcome, and evidence.
Ignore screen ideas for now.
- Run small rounds and adjust.
GOV.UK says methods such as in-depth interviews and usability testing often use around 4 to 8 participants per round (Plan user research for your service).
The goal is not a full process map of everything the department does. The goal is a dependable definition of one action, with enough edge cases to design the first version well.
Worked example: a fictional intake workflow built around one action
Hypothetical example using synthetic data
Assume a team requests an internal tool for handling refund exceptions. Normal refunds are automatic. Exceptions require human review.
The first request list looks like this:
- queue dashboard
- customer timeline
- support notes panel
- analytics chart
- permissions admin
- CSV export
That is a list of surfaces, not a design.
Now reduce it to one accountable action:
Approve, reject, or escalate a refund exception.
Step 1: define the action clearly
| Element | Definition |
|---|---|
| Actor | Operations lead on duty |
| Trigger | A refund request is flagged as an exception |
| Input | Order data, payment status, amount, reason code, account history, support notes |
| Decision | Approve, reject, or escalate |
| Outcome | Refund status changes and follow-up workflow is triggered |
| Evidence | Who acted, when, on which request, with what result and rationale |
At this point the tool has a purpose. It exists to help an operations lead complete a bounded decision.
Step 2: create the minimum decision packet
The reviewer should not have to assemble routine facts across five systems.
Synthetic example packet:
Request ID: RX-10428
Order ID: O-88219
Customer account age: 14 months
Requested refund: $184.00
Original order total: $184.00
Reason code: duplicate shipment claim
Prior refunds in past 12 months: 0
Payment status: settled
Open chargeback: no
Support summary: customer reported receiving duplicate parcel on 2026-10-28
Lead approval threshold: up to $250.00
This packet is intentionally narrow. It contains facts needed for this decision, not a full customer dossier.
Step 3: define decision rules before drawing screens
Synthetic rules:
- If payment status is not
settled, approval is blocked. - If there is an open chargeback, the request must be escalated.
- If the requested refund is greater than
$250.00, the operations lead cannot approve it. - If required fields are missing, the request stays pending.
- If none of the above apply, the operations lead may approve or reject.
Now the example can be checked logically. The request amount is $184.00, which is below the lead threshold of $250.00. Payment is settled, and there is no open chargeback. So the lead is allowed to make the decision.
Step 4: define permissions around operations, not page access
OWASP separates authorization from authentication and recommends least privilege, deny-by-default behavior, and permission checks on every request (Authorization Cheat Sheet). That matters because hiding a button in the interface is not enough; the server-side action must still verify permission.
A basic permission matrix for this fictional workflow:
| Role | View request | Add note | Approve up to $250 | Approve above $250 | Export records |
|---|---|---|---|---|---|
| Support agent | Yes | Yes | No | No | No |
| Operations lead | Yes | Yes | Yes | No | Limited |
| Finance manager | Yes | Yes | Yes | Yes | Yes |
This matrix is useful because it defines operations on resources, not vague access levels like “admin” or “staff.”
Step 5: define the evidence record
OWASP’s logging guidance explains that application logging supports both operational and security use cases, and that the application itself has important context about the user, target, action, and result (Logging Cheat Sheet).
A synthetic event record for this action might be:
interaction_id: INT-778211
event: refund_exception_decision
actor_id: user_204
actor_role: operations_lead
target_request_id: RX-10428
action: approve
result: success
reason_code: payment_settled_amount_within_threshold
timestamp_utc: 2026-11-03T14:11:22Z
OWASP also warns against recording items such as passwords, access tokens, session identifiers in raw form, and sensitive personal data directly in logs (Logging Cheat Sheet). So the log should support reconstruction of the decision without becoming a copy of every sensitive record.
Step 6: verify the normal path
Walk the example end to end:
- Exception request enters queue.
- Support agent adds a short note.
- Operations lead opens the request.
- Tool shows decision packet.
- Server checks role and threshold.
- Lead approves the
$184.00request. - Refund status updates.
- Event record is written.
If the reviewer still needs Slack messages, memory, or manual copy-paste for routine cases, the design is incomplete.
A reusable design procedure for future tools
When the team asks for “an internal system,” use this sequence before discussing UI layouts.
The one-action procedure
- Name the action in one verb phrase.
Example: “release supplier payment batch.”
- Assign one accountable actor.
Use a real role with decision authority.
- Describe the trigger.
What event starts the work?
- List the minimum required inputs.
Remove everything that is merely nice to know.
- Define the business outcome.
What state changes after success?
- Specify the evidence requirement.
What record must exist later?
- Map top exceptions.
Missing data, duplicates, threshold breaches, policy conflicts.
- Set authorization rules.
Who can view, create, approve, reject, escalate, export?
- Prototype the normal path and one difficult edge case.
- Test with real users and recent examples.
Review checklist
| Check | Pass condition |
|---|---|
| Action is singular | The team can describe one core action in one sentence |
| Actor is explicit | One role is accountable for the decision |
| Inputs are bounded | Routine cases do not require hunting through unrelated tools |
| Outcome is concrete | Completion changes a business state |
| Evidence is defined | A reviewer can reconstruct what happened later |
| Permissions are specific | Allowed operations differ by role and are checked server-side |
| Exceptions are known | The major failure paths are handled intentionally |
| Research is grounded | The design reflects real examples from users |
| Logging is selective | Important events are recorded without storing prohibited data |
| First version is small | Scope centers on the main action, not reporting extras |
How to check the result, plus assumptions and limits
A design is not successful because it looks coherent in a workshop. It is successful when the intended actor can complete the accountable action reliably and the team can verify that the result is correct.
What to check after design or first release
- Routine completion: can the actor finish the normal case without switching tools?
- Decision consistency: do similar cases produce similar outcomes?
- Exception handling: do blocked cases route somewhere explicit?
- Permission behavior: are allowed and disallowed actions both tested?
- Evidence quality: can someone reconstruct who did what, to which record, and with what result?
OWASP specifically recommends testing whether the permissions defined in design are actually enforced (Authorization Cheat Sheet). GOV.UK also recommends keeping research findings accessible to the team and using them to support design decisions over time (Plan user research for your service).
Assumptions
This approach assumes:
- the workflow contains a meaningful human decision or accountable task
- one action can be isolated for an initial release
- current users are available for interviews or walkthroughs
- the required input data can be assembled from existing systems or integrations
Limits
This is not a universal design frame for every internal system. It is strongest when one person or role is clearly responsible for a specific action. It is less complete for:
- exploratory analytics environments
- broad collaboration spaces with no single decision owner
- programs whose first problem is poor underlying data quality
Even in those cases, it can still define the first dependable workflow inside a larger platform.
Common mistakes
- Starting with screens instead of responsibility
The tool becomes a dashboard with no operational center.
- Combining many actions into version one
Approval, investigation, reporting, and reconciliation get mixed together.
- Using role labels without operation rules
“Admin” is not a permission model.
- Skipping evidence design
The action works in the moment but is hard to review later.
- Relying on UI-only access control
Hidden buttons do not replace request-level checks.
- Logging too much
Sensitive data leaks into logs that were meant only for accountability.
Designing an internal tool around one accountable business action does not make every workflow simple. It does, however, force useful clarity. You identify who acts, what they need, what changes, and what record remains. Once those pieces are solid, the interface becomes a means to complete the work — not the definition of the work itself.