Internal Tools

Internal Tool Requirements Template: Specify the Work, Not Just the Screen

For the process owner who can explain the job but needs a build-ready brief that captures the normal path, the awkward cases, and what happens after launch.

Uli PrantzBuilds and operates all-agents
Published
Key takeaways

Key takeaways

  • Write the operating outcome before sketching the interface.
  • Requirements need real exceptions, approval boundaries, evidence, and failure behavior, not only happy-path fields.
  • Record data sources and permissions at field and action level where consequence requires it.
  • Name an owner for decisions, incidents, changes, and retirement.
  • Use acceptance cases that can be replayed after every change.
An internal tool requirements document should define the operating job before the screen: outcome, users, trigger, finish state, data, rules, judgment, exceptions, actions, permissions, approvals, evidence, service expectations, acceptance cases, rollout, fallback, ownership, change, and retirement. Attach representative normal and failure cases. The result should let a builder explain what happens when input is missing, an API times out, a user lacks authority, or the process itself changes.

Start with the copyable template

The template is intentionally broader than a feature brief. An internal tool is an operating system for a bounded piece of work, so its specification must cover the interface and the responsibilities below it.

Checklist

Internal Tool Requirements Template

A copyable markdown specification for the job, users, triggers, data, rules, exceptions, approvals, evidence, security, rollout, ownership, changes, fallback, and retirement.

Preview the file
# Internal tool requirements template

Complete this with the people who perform and receive the work. Attach sanitized representative cases. Never paste live secrets, tokens, personal data, customer confidential data, or exploitable architecture details into a shared brief.

## 1. Job and outcome

- Tool or working name:
- Accountable service owner:
- Business decision owner:
- Problem in one sentence:
- Trigger that creates exactly one item:
- Observable finish states:
- Users and roles:
- Service expectation or deadline:
- Current manual process and fallback:
- Measures before change: volume, active time, elapsed time, corrections, exceptions, missed work, harmful outcomes:

## 2. Scope

- In scope for version one:
- Explicitly out of scope:
- Users, records, locations, and volume limits:
- Actions allowed automatically:
- Actions produced only as drafts:
- Actions requiring permanent human approval:
- Stop conditions:

## 3. Inputs and data

For each input record the field, source of truth, owner, required or optional status, validation, freshness, sensitivity, purpose, retention, deletion, masking, and missing-data path.

| Input | Source | Owner | Validation and freshness | Sensitivity and purpose | Missing-data path |
| --- | --- | --- | --- | --- | --- |
|  |  |  |  |  |  |

## 4. Workflow behavior

- Normal states and transitions:
- Deterministic rules and calculations:
- Bounded AI judgment, allowed outputs, examples, confidence or abstention behavior:
- Notifications and their owners:
- Duplicate identity and business key:
- Exactly what happens after approval, rejection, expiry, withdrawal, or cancellation:

## 5. Exceptions and failures

Describe at least three real exceptions. Include missing input, invalid input, duplicate request, stale state, denied authority, dependency unavailable, timeout after possible effect, partial effect, and notification failure where applicable.

| Condition | Detection | State and owner | Allowed action | Evidence | Return or close path |
| --- | --- | --- | --- | --- | --- |
|  |  |  |  |  |  |

## 6. Identity, authority, and secrets

- Human authentication method:
- Service identities and environments:
- Default-deny authorization model:
- Record, field, function, and action permissions by role:
- Approval authority, delegation, evidence, expiry, and version binding:
- Secret storage, access, rotation, revocation, and log exclusion:
- Rate, value, batch, and scope limits:

## 7. Evidence and monitoring

- Request and input version retained:
- Decision or model version retained:
- Approval or rejection actor, time, evidence, and scope retained:
- Attempted effect, destination response, confirmed postcondition, correction, and final outcome retained:
- Business outcome metrics:
- Technical and dependency health metrics:
- Alert condition, recipient, immediate action, severity, and duplicate suppression:
- Exception queue owner, service clock, and escalation:

## 8. Acceptance cases

Attach at least two normal cases, two boundary cases, three exceptions, one duplicate, one denied action, one stale-input case, one timeout-after-possible-effect case, and one recovery case. For each, specify inputs, expected state path, permitted effects, evidence, and owner.

## 9. Rollout and recovery

- Historical replay plan:
- Observation or draft-mode plan:
- First live users, records, actions, and volume:
- Manual fallback and how it is activated:
- Maximum acceptable outage or backlog:
- Effect reconciliation method:
- Rollback or compensation path:
- User correction and incident reporting path:
- Release decision owner and evidence:

## 10. Change and retirement

- Dependency inventory and notice owners:
- Policy and process change owner:
- Versioning and regression suite:
- Change reviewer, approver, release, verification, and communication path:
- Review cadence:
- Value and ownership review date:
- Retirement triggers:
- Export, evidence retention, trigger shutdown, credential revocation, user notice, and archive steps:

## Decision record

- Chosen delivery model:
- Alternatives considered:
- Assumptions that must remain true:
- Highest-consequence failure and its control:
- Named reviewers:
- Decision date:
- Next review date:

Define the job and finish state first

The opening fields prevent a screen-first project.
FieldUseful answerWeak answer
OutcomeAn accepted supplier request with owner, decision, and evidenceMake supplier admin easier
TriggerA complete request enters the named intake channelWhenever someone needs it
Finish stateApproved, rejected, withdrawn, or escalated with the destination updatedDone
UsersRequester, reviewer, decision owner, support owner, auditorOperations
Service expectationNormal requests decided within two working daysAs soon as possible

Specify behavior with examples and exceptions

  1. 01Write the normal pathCode
    Name each state, required input, rule, action, postcondition, and receiving owner.
  2. 02Attach real casesHuman approval
    Include at least two normal examples, two boundary cases, and three exceptions with sensitive details removed.
  3. 03Bound judgmentAI judgment
    For ambiguous inputs, provide allowed classes, decision factors, examples, confidence or abstention behavior, and review rules.
  4. 04Place approvalsHuman approval
    State who can approve, what evidence they see, expiry, delegation, and the exact effect of approval or rejection.
  5. 05Define failureTrigger
    Cover missing data, duplicate input, stale state, denied access, timeout, partial effect, unavailable dependency, and notification failure.

Make authority, evidence, and data explicit

  • Identity for every human and service; permitted records, fields, functions, and actions; default-deny behavior.
  • Data classification, source of truth, purpose, retention, deletion, export, masking, and environment separation.
  • Secret owner, storage, access, rotation, revocation, and rules preventing sensitive values from entering logs.
  • Evidence for request, input version, decisions, approvals, attempted and confirmed effects, errors, corrections, and final outcome.
  • Alert conditions, recipient, expected action, severity, duplicate suppression, and recovery confirmation.

NIST's SSDF recommends maintaining security requirements over time, protecting software components, producing well-secured releases, and responding to residual vulnerabilities. Requirements should therefore cover change and operation, not stop at launch.

Turn requirements into replayable acceptance cases

Every case states inputs, expected path, permitted effects, evidence, and owner.
CaseExpected proof
NormalCorrect state and one confirmed effect with complete evidence
Missing inputNo effect; request names the missing fact and its owner
DuplicateOne business outcome; later attempt links to the original
Denied authorityNo effect; denial is recorded without exposing sensitive values
Timeout after actionRun pauses, reconciles destination by business key, and avoids a duplicate
Changed ruleOld behavior remains versioned; new behavior passes regressions and receives approval

End with ownership, fallback, change, and retirement

  • Service owner and business decision owner.
  • Security or privacy contact where applicable.
  • Support intake, severity, incident path, and user communication owner.
  • Manual fallback, maximum acceptable outage, and catch-up or reconciliation procedure.
  • Dependency inventory, change detection, regression suite, approval, release, and rollback.
  • Retention and retirement trigger, data export, credential revocation, user notice, and archive.

Limitations and when not to use this

  • A template cannot replace observing the actual work or resolving policy disagreement among its owners.
  • This is not a substitute for security architecture, privacy, legal, accessibility, financial, employment, or regulated-domain review.
  • Do not include live secrets, personal data, customer confidential data, or exploitable architecture details in a shared requirements document.

Sources

  1. Secure Software Development Framework 1.1NIST Accessed 14 August 2026
  2. Testing for ReliabilityGoogle Site Reliability Engineering Accessed 14 August 2026

Download the requirements template

Complete it with the people who perform and receive the work, then attach two normal cases and three exceptions.

Download the requirements template
About the author

Uli Prantz

Builds and operates all-agents

Uli Prantz builds all-agents, the process-automation platform this site documents. He writes about the operational side of automating recurring business work: where deterministic code beats model judgment, where it does not, and where a human still has to approve.

Bring one process. We will scope it in 30 minutes.

You leave the call knowing whether it is a fit, what can become code and what still needs a person.

Book a discovery call