---
title: "When a Spreadsheet Approval Process Needs a Small Internal App"
description: "A spreadsheet approval process needs an app when versions, status, or approvers are unclear and a configured workflow fails a specific rule."
url: https://ziplyne.agency/blog/when-a-spreadsheet-approval-process-needs-a-small-internal
published: 2026-11-20T14:12:14.621Z
updated: 2026-11-20T14:12:14.621Z
author: "ZipLyne Editorial"
publisher: ZipLyne
---

# When a Spreadsheet Approval Process Needs a Small Internal App

> Decide whether to build, configure a workflow tool, or wait until the rules are clear. Use the five-rule checklist to test approval behavior before committing.

## When does a spreadsheet approval process need a small internal app?

A spreadsheet approval process doesn't automatically need a small internal app. It needs one when the team can't tell the current version, the status, or the next approver without asking in chat or email, and a configured workflow tool still can't meet a specific rule. [Smartsheet's documentation](https://help.smartsheet.com/articles/2479276-request-approval-from-stakeholders) shows ordered approvals that pause until someone approves or declines.

Roberto Cortez, writing on approval portals, puts the line in the same place. A spreadsheet stays sufficient while people can find the right version, understand the request's status, and identify the next person to act. Repeated clarification about those three things is the signal to investigate.

That gives you a three-way test, and the rest of this piece walks through it:

- **Buy or configure** when a workflow tool you already have passes a real test with your real rules.
- **Build** when a specific requirement fails that test, the failure isn't a setup problem, and someone will own the app afterward.
- **Defer** when nobody can state the approval rules cleanly yet.

The scenario below is one illustrative purchase request, not a client case.

## What does one purchase request look like in a spreadsheet today?

This purchase request is a hypothetical example, not a client case and not measured data. It shows how one request can sit in a Google Sheets or Excel file, a Google Forms intake, and Slack or Microsoft Teams threads at once. Oleg Sotnikov's spreadsheet workflow review says a review works only when you map the real work instead of the official process, including exports, copied workbooks, chat, email, and private notes.

**In this illustrative purchase request, information is split across a spreadsheet, an intake form, chat, and private notes.** The official process says "submit, manager approves, finance pays." The real one has more steps. Before you design anything, list every place a request leaves the file.

The values below are made up to show where the records split.

| Field | What the sheet shows | What actually happened |
|---|---|---|
| Requester | Name typed in column A | Submitted through a Google Forms intake, then retyped by hand |
| Amount | Figure in a cell | Edited in a copied workbook after the manager said yes |
| Attachment | Link in a notes cell | Quote revised and re-sent by email; the link points to the old file |
| Status | "Approved" | Set by the requester after a Slack or Microsoft Teams thread, not by the approver |
| Approver | Manager's name | Manager was out; a colleague said "fine" in chat |

In this scenario, nobody can say which amount and which quote the approver reviewed. That is the gap an approval system has to close.

## Can a configured approval workflow handle it before you build anything?

Smartsheet's documentation describes configured approval workflows that pause until a stakeholder approves or declines, then follow the configured outcome path. A plain workbook and workflow software built on a sheet are different things. Test the configured option against your real rules before you commission anything.

[Smartsheet's documentation](https://help.smartsheet.com/articles/2479276-request-approval-from-stakeholders) also shows where configured approvals have sharp edges:

| Behavior | What the documentation says | What to test |
|---|---|---|
| Ordering | Approval requests pause the workflow until approved or declined | Does your real chain of approvers fit that order? |
| Outcome actions | Actions run when status enters Approved or Declined and don't consider conditions defined before the request | Does an edit after submission slip through? |
| Locking | Locking approval-status columns is best practice; a locked row blocks approving or denying, a locked approval column doesn't | Can the requester still change status by hand? |
| Triggers | Cross-sheet formulas or linked cells in the trigger cell don't start the approval request | Does your sheet depend on linked cells? |
| Volume | [Smartsheet](https://help.smartsheet.com/articles/2479276-request-approval-from-stakeholders) allows up to 5,000 approval request actions in a single workflow execution | Is your batch anywhere near that? |

Smartsheet's 5,000-action figure is a limit on its own workflow executions. It isn't a universal point where spreadsheets break, and the documentation carries no publication year.

Microsoft Power Automate, Microsoft Teams, and Jira Service Management are other options worth testing. The sources supplied here don't document their approval behavior, so run your purchase request through each before ruling anything in or out. For the broader upgrade question, see the post titled [Custom Internal Tools vs Spreadsheets: When to Upgrade](https://ziplyne.agency/blog/custom-internal-tools-vs-spreadsheets-when-to-upgrade).

> **Tip:** Write down which rule the tool failed on. "It felt clunky" isn't evidence. "It let a requester change the amount after approval" is.

## Which rules must an approval system enforce?

An approval system must enforce five rules: explicit states, approval tied to the reviewed version, server-side authority, a replacement rule for absent approvers, and decision evidence kept on the request. They come from Roberto Cortez's approval-portal guidance. A custom build is relevant only where a configured tool can't meet one of them.

Treat the list as a starting acceptance checklist applied to a purchase request. It is illustrative and doesn't certify a tool as production-ready.

1. **Explicit entry and exit conditions per state.** For draft, submitted, in review, approved, and declined, define who may act, what must be complete first, and what decision information must be kept.
2. **Approval tied to the version reviewed.** Decide whether a changed amount, changed wording, or new attachment sends the request back to review. When it does, the earlier history stays.
3. **Server-side authorization.** Hiding an approval button protects nothing. The application has to check, on the server, whether this person may change this request.
4. **A replacement rule for absent approvers.** The decision history must still show who actually acted.
5. **Decision evidence on the request.** Someone else should be able to reconstruct the decision later.

Here is a hypothetical protected record for the purchase request:

| Field | Illustrative value |
|---|---|
| Version reviewed | Version 2 (amount and wording as submitted) |
| Attachment version | Quote file, version 2 |
| Approving actor | Stand-in approver, acting under the absence rule |
| Decision | Approved, with date and time |
| Earlier history | Version 1 approval kept and marked superseded after the amount edit |

Requested changes need a rule too. The sources don't prescribe one, so this is illustrative. The reviewer states what must change, the request returns to the requester, only the requester may edit it, and resubmission re-enters review as a new version.

Turn each rule into a test before any screen gets built:

- **Incomplete submission:** a request missing its attachment can't enter review.
- **Unauthorized attempt:** a requester approving their own request is refused at the server, not just hidden in the interface.
- **Material edit after approval:** changing the amount returns the request to review, and the first approval stays in the history.
- **Absent approver:** the stand-in acts under a defined rule, and the record names the stand-in.
- **Reconstruction:** another person can say who approved which version, and why, from the record alone.

A failed check tells you what to investigate. Decide whether it's a configuration problem or a requirement the tool can't meet. Recovery, notification retries, concurrent approvals, integration failures, and full production acceptance aren't established by the supplied sources. They stay open project questions. For background, see the post titled [How to Build an Internal Tool That Replaces Spreadsheet Ops](https://ziplyne.agency/blog/how-to-build-an-internal-tool-that-replaces-spreadsheet-ops).

## Should you build, buy, or defer an approval app?

Configure or buy a workflow tool first if it passes a test with your real approval rules. Build a small approval app only when a named requirement fails that test and someone will maintain the result. Defer when approvers can't state the rules. The sources contain no verified cost or break-even estimate for this approval app.

| Call | Trigger evidence | What would change it |
|---|---|---|
| Buy or configure | A workflow tool passed the starting acceptance checks with real requests, or its failures trace to setup | A later failure on an exception path |
| Build | A named requirement failed a real test and isn't a configuration problem, people keep asking "which version, who's next," and a named owner will maintain it | The owner disappears, or the failure turns out to be a setup problem |
| Defer | Approvers disagree on the rules, or the sheet is full of one-off patches | The rules get written down and signed off |

Defer deserves a closer look. Sotnikov's workflow review says temporary spreadsheet patches should be separated from durable business rules before implementation. Copy every workaround into code and you've preserved the problem in a new place.

Before committing, get project-specific estimates for configuration, build, and ongoing maintenance. Don't borrow a number from another article. The [WallFlow guide](https://www.wallflow.pro/blog/custom-crm-vs-off-the-shelf-small-business) covers CRMs and gives inconsistent build thresholds across its checklist and FAQ, so treat universal thresholds with suspicion. It does make a useful ownership point: register the database and hosting accounts in your company name and confirm you can export all your data.

> **Watch out:** Track how often people ask "which version?" and "who's next?" in chat and email. That count is your own evidence for a build.

## What does it take to move off the spreadsheet?

Moving off a spreadsheet approval process takes five steps: trace complete requests, write down the rules, build the smallest version that passes your acceptance checks, run it alongside the sheet, and cut over. This sequence is a proposed approach to validate per project. The supplied sources don't establish rollout, recovery, or rollback procedures, or any timeline.

1. **Trace complete requests.** Follow real ones from submission to payment, including exceptions. Note every uncertainty, version confusion, and manual step.
2. **Write down the rules.** Separate durable rules from temporary patches, and get approvers to agree on the durable ones.
3. **Build the smallest version that passes the acceptance checks.** Limit it to the states and tests you wrote down.
4. **Run it alongside the sheet.** Keep the sheet as the working record until outputs match on live requests.
5. **Cut over.** Before you do, agree what happens to the old sheet and how you'd roll back if the new tool misbehaves.

Will your team have to change how they work? A little, by design. In this illustrative setup, requesters submit through one intake instead of editing the sheet. Approvers act on the request itself instead of typing a status. The requester edits until submission. After that, a material edit sends the request back to review.

## What should you bring to a project discussion?

For an approval-app project discussion, bring a brief with representative real requests including exceptions, the roles that submit, approve, and stand in, required documents, unresolved rules, connected tools, data ownership and export terms, a maintenance owner, and the result of your configured-tool test. Those inputs let the discussion start from your actual workflow.

- **Representative real requests,** including the ones with exceptions. If you want a starting size, 5 to 10 is an optional suggested sample, not a requirement.
- **Roles:** who submits, who approves, and who may stand in.
- **Required documents** for each request type.
- **Unresolved rules,** stated as questions.
- **The tools it must connect to,** such as your intake form or chat.
- **Data ownership and export:** who holds the accounts, and how you get your data out.
- **Maintenance:** who owns the app after launch.
- **What the configured-tool test showed,** including the exact rule that failed.

ZipLyne is Isaac Horowitz's solo agency, and it builds internal tools and AI automation for businesses.

Before any conversation, run your three most awkward requests through the configured tool and write down each rule it failed to enforce.

---

Originally published at https://ziplyne.agency/blog/when-a-spreadsheet-approval-process-needs-a-small-internal
