GenFrontier homeScope a project
Menu
Reader questionHow do we write requirements for warehouse and tracking software so that vendors can estimate them and testers can prove them?

Writing logistics software requirements your team can test

How to write warehouse software requirements vendors can estimate and testers can prove, with worked ASN receiving, short pick and lot capture examples.

field-notes / implementation / testable-logistics-software-requirements
A fan of steel feeler gauges beside two wooden blocks, one red gauge slid exactly into the gap between them

Write each warehouse software requirement as one numbered statement that names the actor, the trigger, the data, the business rule and the exception path. Attach at least one acceptance test with concrete data and an expected result, and state non-functional needs such as scan response time, offline behavior and throughput as numbers with conditions. Then trace every requirement to the user acceptance testing (UAT) cases that prove it. A vendor can estimate a requirement written this way, and a tester can pass or fail it.

This field note shows that anatomy on three warehouse cases (receiving against an ASN, a short pick, and lot and expiry capture) and one tracking case. It sets out non-functional requirements with numbers, the information vendors need to estimate, and a traceability matrix that runs from requirement to UAT result.

What makes warehouse software requirements testable

A requirement is testable when two people can run the same test and agree on whether it passed. That needs a single behavior, a named condition, measurable values and an expected result. Everything else in this field note follows from that definition.

The standards behind it

The international standard for the subject is ISO/IEC/IEEE 29148:2018, Systems and software engineering, Life cycle processes, Requirements engineering. The IEEE listing describes it as an active standard that “defines the construct of a good requirement, provides attributes and characteristics of requirements” (IEEE Standards Association). It replaced the 2011 edition.

The full standard is a paid document. A free and practical companion is Appendix C of NASA’s Systems Engineering Handbook, “How to Write a Good Requirement” (NASA). Its checklist asks whether each requirement expresses “only one thought per requirement statement” and whether it has “one subject and one predicate”.

Shall, will and should

NASA’s appendix gives three words three different jobs: “Shall = requirement”, “Will = facts or declaration of purpose” and “Should = goal”. Use them consistently. A document that mixes “must”, “needs to”, “shall” and “should” leaves the vendor to guess which statements are binding.

Four ways to verify

NASA’s checklist asks: “Can the system be tested, demonstrated, inspected, or analyzed to show that it satisfies requirements?” Those are four verification methods, and naming one for each requirement tells the tester what to prepare.

Method What it means Warehouse example
Test Run the function with set inputs and measure the output Scan an SSCC and time the response on the handheld
Demonstration Show the function working, without detailed measurement Show a supervisor approving an adjustment from a tablet
Inspection Examine the product, document or configuration Check that the GS1-128 label layout includes the required fields
Analysis Use calculation or models instead of a live run Calculate that the label printers can meet peak-hour volume

Words that cannot be tested

NASA’s checklist lists unverifiable terms to remove, including “flexible, easy, sufficient”, “user-friendly”, “fast”, “quickly” and “easily”. It also flags “as appropriate,” “etc.,” “and/or,” and “but not limited to”. Each one hides a decision someone has not made yet.

Untestable wording Testable rewrite
Scanning shall be fast 95% of SSCC scans shall show the expected receipt within 1.0 second, measured on the handheld
The system shall handle exceptions as appropriate When a scanned SSCC is not on any open ASN, the system shall place the pallet in status “unexpected” and notify the receiving supervisor
Users shall be able to search orders easily A customer service user shall find an order by PO number, order number or customer reference in one search field
The system shall support lots, expiry, etc. For lot-controlled items, the system shall record lot number and expiry date on every receipt, move and shipment
Labels and/or packing lists shall print A GS1-128 pallet label shall print at the pack station within 3 seconds of pack confirmation

The numbers in the right-hand column are examples. Set your own from your volumes, your devices and what your floor will accept.

The anatomy of a logistics requirement

A logistics requirement has six parts: actor, trigger, data, rule, exception path and acceptance criteria. Leave one out and the estimate comes back wide, or the argument about what passed starts in UAT.

Part Question it answers Example from receiving
Actor Who or what starts the behavior? Receiver with a handheld scanner at a dock door
Trigger What event starts it? Scan of the SSCC barcode on an inbound pallet label
Data What information goes in and comes out? ASN with SSCC, PO, item, lot and quantity per pallet; open PO lines
Rule What must the system decide or calculate? Match the SSCC to an open ASN for this appointment and compare quantities
Exception path What happens when the normal case fails? SSCC not on any ASN, already received, or label unreadable
Acceptance criteria How will we know it works? Given, when and then statements with set data and expected results

Functional and non-functional, defined

A functional requirement states what the system must do in response to an event, such as recording a receipt when an SSCC is scanned. A non-functional requirement states how well it must do it, such as how fast, how often, for how many users, or with what security and audit record. Both need the same anatomy and the same acceptance tests; only the measures differ.

Write the requirement card

Keep each requirement on one card or one row with the same fields. A consistent layout makes gaps visible: an empty exception field is a question for the next review.

  • ID: unique and permanent, such as REC-014. NASA’s checklist asks that each requirement be “uniquely numbered” for reference.
  • Statement: one “shall” sentence.
  • Rationale: why it exists, in one line. NASA’s checklist suggests asking, “What is the worst that could happen if the requirement was not included?”
  • Actor, trigger, data, rule, exceptions: as in the table above.
  • Verification method: test, demonstration, inspection or analysis.
  • Acceptance tests: at least one for the normal path and one for each exception.
  • Priority and owner: must, should or could, and the person who can answer questions about it.
  • Status of values: any number not yet agreed is marked TBR, to be resolved, with an owner and a date, as NASA’s appendix recommends.

User stories and acceptance tests

If your team works in user stories, the anatomy still applies. The Agile Alliance glossary describes user stories as “functional increments” and lists the “Card, Conversation, Confirmation” model, where the confirmation is the test (Agile Alliance). It defines an acceptance test as “a formal description of the behavior of a software product, generally expressed as an example or a usage scenario” (Agile Alliance).

A story such as “As a receiver, I want to scan a pallet and see what should be on it, so that I can check it before I break it down” is a good conversation starter. It is not yet testable. The acceptance tests below are what make it one.

Given, when, then

The Gherkin format from the Cucumber testing tool gives acceptance tests a fixed shape, and it reads well even if you never automate the tests. “Given steps are used to describe the initial context of the system”, “When steps are used to describe an event, or an action” and “Then steps are used to describe an expected outcome, or result” (Cucumber). A “Scenario Outline” runs the same test “multiple times, with different combinations of values”, one per row of an Examples table. That suits warehouse exceptions, which are usually the same steps with different data.

Worked example: receiving against an ASN

Receiving against an advance ship notice (ASN) is the clearest place to start, because the data arrives before the truck. In X12 EDI the ASN is the 856 transaction set, which X12 names “Ship Notice/Manifest” (X12). Each pallet is identified by a Serial Shipping Container Code (SSCC). GS1 assigns it Application Identifier (AI) (00), with an 18-digit fixed-length format (GS1).

The requirement

REC-014. When a receiver scans the SSCC on an inbound pallet at a dock door, the system shall match it to an open ASN line for the supplier’s appointment at that door and display the expected items, lots and quantities.

  • Actor: receiver with a handheld scanner.
  • Trigger: scan of the SSCC barcode on the pallet’s GS1-128 label.
  • Data: ASN header (supplier, PO, appointment), pallet-level SSCC, item, lot, quantity; open PO lines.
  • Rule: the SSCC must appear on an ASN for this supplier with status “in transit” or “arrived”, and not already received.
  • Verification: test.

Acceptance tests for the normal path

Example (fictional). ASN EX-ASN-3301 from a fictional supplier lists SSCC ending 0457, holding 40 cases of item EX-20118, lot L2611, against PO EX-PO-7781.

  • Given ASN EX-ASN-3301 has status “arrived” for the appointment at door 4
  • And it lists SSCC ending 0457 with 40 cases of EX-20118, lot L2611
  • When the receiver at door 4 scans SSCC ending 0457
  • Then the handheld shows EX-20118, lot L2611, expected 40 cases, PO EX-PO-7781
  • And the pallet status changes from “in transit” to “at dock”
  • And the receiver is prompted to confirm the case count

The exception paths

The normal path is usually the smallest part of the work. Write each exception as its own row in a scenario outline, so the vendor can see and price every branch.

Scan situation Expected system behavior Who is notified
SSCC not on any open ASN Pallet status “unexpected”; receiver prompted to scan item and enter quantity; receipt held for review Receiving supervisor
SSCC on an ASN for a different appointment Warning shows the correct appointment; receipt allowed only with supervisor approval Receiving supervisor
SSCC already received Scan rejected with the original receipt date, time and user None; message to receiver
Label unreadable Receiver keys the 18 digits; system validates the check digit before searching None
Counted cases differ from ASN Receipt posts at counted quantity; variance recorded with a reason code Buyer, for supplier follow-up
No ASN for the shipment Receive against PO lines by item scan; the missing ASN is logged against the supplier Buyer

Each row becomes at least one acceptance test with its own data. Six rows, six tests, and the vendor’s estimate now has something to count.

What a vendor can now count

Written this way, REC-014 gives an estimator concrete units of work. There is one handheld screen for the scan and the expected contents. There are six exception branches, each with a message and a status. There is one inbound interface, the 856, and one data lookup against open PO lines. There are three notification types, to the supervisor, the buyer and the receiver. A vendor whose product already does most of this can say so line by line, and a developer building it can size each branch.

Three gaps to check in receiving requirements

Three gaps are easy to miss. The requirement does not say whether the receiver sees the expected quantity before counting, which decides whether the count is blind. It does not say what “matches” means when the supplier ships 41 cases against 40. And it assumes the ASN arrives before the truck, without saying what happens when it does not.

If your ASNs come from trading partners, the structure of the 856 itself matters to these rules. Our field note on which 856 hierarchy to send and how to make the ASN match the truck covers that side.

Worked example: a short pick

A short pick happens when the picker cannot find the requested quantity at the location the system sent them to. It looks like a small exception, but it touches inventory accuracy, order fulfillment and the customer, so its requirement has more branches than most.

The requirement

PCK-022. When a picker confirms a quantity lower than requested at a pick location, the system shall require a short reason, direct the picker to the next location holding available stock of the same item and lot status, and create a count task for the shorted location.

  • Actor: picker with a handheld; system as the second actor for redirection.
  • Trigger: confirmed pick quantity lower than the task quantity.
  • Data: pick task, location balances, alternative locations, reason code list, order line and customer’s partial-shipment rule.
  • Rule: redirect only to locations in the same pick zone with available status; never adjust inventory until the count task confirms the real quantity.
  • Verification: test.

Decisions the requirement has to settle

A short pick forces four decisions that the business, not the developer, should make:

  1. Redirect or short? Does the system send the picker to another location, or short the line and move on?
  2. Adjust now or count first? Writing off stock on the picker’s word double-counts losses when the stock turns up in the next bin.
  3. What happens to the order? Ship partial, hold the order, or backorder the line, by customer rule.
  4. Who is told? The inventory controller always; customer service only when the line ships short.

Example (fictional). Pick task PT-55102 asks for 12 eaches of EX-41207 from location A-14-03-B. The system shows 12 on hand there. Location A-16-02-A holds 30 available eaches of the same item.

  • Given location A-14-03-B shows 12 eaches of EX-41207 and A-16-02-A shows 30 available
  • When the picker confirms 5 at A-14-03-B and selects reason “location short”
  • Then the handheld directs the picker to A-16-02-A for the remaining 7
  • And a count task is created for A-14-03-B with priority “today”
  • And the on-hand balance at A-14-03-B is not changed until the count is approved

A second scenario uses the same data but no alternative location. Then the line is shorted by 7, the order follows the customer’s partial-shipment rule, and customer service receives a notice only if the order ships short.

Exception paths for the short pick

  • The picker confirms zero: same flow, with reason “location empty”.
  • The picker finds the item but it is damaged: reason “damaged”, quantity moved to a damage location, count task still created.
  • The picker finds a different item in the location: reason “wrong item”, plus a count task, because two records are now wrong.
  • The count later finds the full quantity: the count task closes with no adjustment, and the short reason is recorded as “picker error” for reporting.

The last branch is easy to leave out, and it is the one that keeps adjustment reports honest. Each branch gets its own acceptance test.

Worked example: lot and expiry capture

Lot and expiry capture at receipt decides whether you can rotate stock by expiry and trace a recall. The requirement has to say where the data comes from, how the system checks it and what happens when it is missing.

What the barcode can carry

GS1 defines AI (10) for “Batch or lot number”, up to 20 alphanumeric characters (format N2+X..20), and AI (17) for “Expiration date (YYMMDD)”, six digits (format N2+N6) (GS1). GS1 pairs both with an item identifier such as the GTIN, AI (01). Where the supplier’s case or pallet label carries them, the receiver should not have to type them.

The requirement

LOT-007. For items flagged lot-controlled, the system shall capture lot number and expiry date at receipt from AIs (10) and (17) where the label carries them, or by keyed entry with re-entry confirmation where it does not, and shall place on hold any receipt whose remaining shelf life is below the item’s minimum receiving shelf life.

  • Data: item master flags (lot-controlled, expiry-controlled, minimum receiving shelf life in days), label barcode content, receipt date.
  • Rule: remaining shelf life equals expiry date minus receipt date, in days. Below the minimum, the receipt posts to a hold status, not to available stock.
  • Verification: test.

The rule depends on item master fields that are often empty when a new system goes live. Our field note on the item master data that must be correct before go-live covers how to fill and verify them.

Example (fictional). Item EX-30544 is lot-controlled with a minimum receiving shelf life of 60 days. The receipt date is March 2, 2026.

  • Given EX-30544 has a minimum receiving shelf life of 60 days
  • When the receiver scans a case label with lot AX7731 and expiry date April 15, 2026
  • Then the system calculates 44 days of remaining shelf life
  • And posts the receipt to status “hold, short dated” with lot AX7731
  • And notifies the buyer

The same test with expiry date June 30, 2026 calculates 120 days and posts the receipt to available stock.

Edge cases to write down

  • A day value of 00. GS1’s published pattern for AI (17) accepts 00 in the day position. Check the GS1 General Specifications for its meaning, and state in the requirement how your system stores and displays it.
  • A lot longer than 20 characters. It cannot come from AI (10). Decide whether keyed lots may be longer, and how they print on your own labels.
  • No expiry on the label. Keyed entry with re-entry, or a supervisor override with a reason code.
  • The ASN lot differs from the label lot. Decide which one wins, and log the difference against the supplier.
  • An expiry date already in the past. Reject the scan, never post it.

Non-functional requirements for warehouse and tracking software

Non-functional requirements describe how well the system must work: speed, capacity, availability, behavior without a network, security and audit. In a warehouse they decide whether the floor accepts the system, so write them with numbers and conditions like any other requirement.

Scan response time

Response time is the non-functional requirement the floor feels first. Jakob Nielsen’s limits, first published in his 1993 book Usability Engineering, give a useful frame: “0.1 second is about the limit for having the user feel that the system is reacting instantaneously” and “1.0 second is about the limit for the user’s flow of thought to stay uninterrupted” (Nielsen Norman Group).

A scan response requirement needs four parts: the transaction, the percentile, the measuring point and the load. “95% of SSCC scans at receiving shall display the expected receipt within 1.0 second, measured on the handheld, with 60 users signed in” is testable. “Scans shall be fast” is not.

Where one second of scan response can go Milliseconds from trigger pull to screen (fictional receiving scan) 0.1 s 1.0 s Decode 50 Network 80, render 60 App logic 120 WMS call 350 Total 660 ms, inside 1.0 s
Fictional example breakdown for illustration; measure your own. The 0.1 second and 1.0 second limits are from Jakob Nielsen, Usability Engineering (1993), as published by Nielsen Norman Group, checked November 2026.

The breakdown shows why the measuring point matters. A vendor can meet a server-side response target while the handheld still feels slow. Decoding, the wireless network and the screen render sit outside the server’s clock, and a call to another system can take more time than everything else combined.

A set of warehouse non-functional requirements

The table below shows the kind of statement each area needs. The values are examples for a fictional mid-size site; replace them with your own measured volumes.

ID Area Example requirement Verification
NFR-01 Scan response 95% of receiving and picking scans respond within 1.0 s, 99% within 2.0 s, on the handheld, at peak-hour load Test with load
NFR-02 Offline behavior If the wireless network drops, the handheld queues pick confirmations, shows “offline”, and posts them in order when the network returns, with no duplicates Test
NFR-03 Throughput The system processes 1,800 pick confirmations per hour across 45 handhelds without breaching NFR-01 Test with load
NFR-04 Label printing A GS1-128 pallet label prints within 3 s of pack confirmation Test
NFR-05 Tracking latency A carrier status event appears on the shipment screen within 15 minutes of the interface receiving it Test
NFR-06 Availability The system is available during operating hours, Monday 05:00 to Saturday 22:00; maintenance happens outside them Analysis and monitoring
NFR-07 Audit trail Every inventory transaction records user, device, time, from and to location, quantity before and after, and reason Inspection
NFR-08 Access Only the inventory control role can approve adjustments above the value threshold Test

How to test non-functional requirements

A performance test is only as good as its conditions. Plan the test as carefully as the requirement:

  1. Use realistic data volumes. A test database with 200 items and 50 locations can answer scans faster than production ever will. Load the item and location counts you will run with.
  2. Measure on the device. Time from trigger pull to the screen update, on the handheld model the floor will use.
  3. Test where the signal is weakest. The far end of the building, the freezer, the dock with the trailer doors open.
  4. Simulate the peak hour. Run scripted transactions from the number of handhelds in NFR-03 while testers time real scans.
  5. Record percentiles, not averages. An average of 0.6 seconds can hide one scan in ten that takes four.

If the test cannot be run before go-live, say so in the matrix and agree how the requirement will be verified during the first peak week.

Offline mode needs its own exceptions

Offline behavior is where non-functional and functional requirements meet. State which transactions may run offline (pick confirmations, perhaps) and which may not (receipts against an ASN that the handheld cannot check). Then write the exception paths: what the screen shows, how long the queue may grow, and what happens if two handhelds act on the same stock while one is offline.

Requirements for tracking software

Tracking systems need the same anatomy. Their trigger is usually a message, not a scan. X12 names the 214 transaction set “Transportation Carrier Shipment Status Message”, and carrier APIs deliver similar events in their own formats.

TRK-005 (example). When a carrier status message reports a delivery exception for a shipment with a customer delivery appointment, the system shall flag the shipment “at risk” and notify the account owner. The exceptions to write down: no status update in a set number of hours, a status code the system does not recognize, and events that arrive out of order.

Example (fictional). Shipment EX-SH-90412 has a customer delivery appointment at 08:00 on Thursday.

  • Given EX-SH-90412 has status “in transit” and an appointment at 08:00 Thursday
  • When a carrier status message reports a delivery exception with reason “weather delay” at 17:40 Wednesday
  • Then the shipment shows “at risk” on the tracking screen within 15 minutes
  • And the account owner receives a notice naming the shipment, the appointment and the reason

A second test sends a status code that is not in the mapping table. The shipment keeps its last known status, and the unknown code goes to an integration error queue with the raw message attached.

Writing requirements vendors can estimate

A vendor estimates work by counting things: screens, rules, exceptions, interfaces, reports, labels and data loads. Requirements that make those things countable tend to get narrower estimates and fewer change requests. Vague requirements invite either padded quotes or low quotes followed by change orders.

Give the volumes and the environment

Put a context section before the requirements. Vendors need it to size performance, licensing and hardware, and to judge which requirements are standard for them.

Estimate driver What to state
Volumes Orders, lines, receipts, shipments and scans on an ordinary day and on the peak day, with the month of peak
Sites and users Number of sites, users per shift by role, and shifts per day
Devices Handheld and printer models in use, operating system, and whether they will be replaced
Interfaces Each system and trading partner, with direction, method (API, EDI, file) and message types
Labels and documents Each label and document the system must print, with a sample
Data to migrate Items, locations, open orders and on-hand balances, with counts
Out of scope Processes and sites explicitly excluded

Ask vendors to classify each requirement

Ask every vendor to answer each requirement in the same format. A classification column turns a pile of proposals into a comparison.

  1. Standard: works as delivered.
  2. Configuration: met with settings in the vendor’s supported tools.
  3. Extension: met with separate code through supported interfaces.
  4. Custom development: needs changes to the product itself.
  5. Not supported.

Ask for an estimate against every answer other than “standard”, and for the assumptions behind it. That classification is also the evidence for the larger decision covered in our field note on whether to buy, configure, extend or build.

Attach samples, not descriptions

A sample answers questions that a paragraph cannot. Attach, with sensitive fields removed:

  • A few real ASNs from your largest suppliers, including one that was wrong.
  • Photos of pallet and case labels as they arrive, including a damaged one.
  • Every label and document you print today: pallet labels, packing lists, bills of lading.
  • An export of item master data for a representative set of items.
  • A location list for one zone, with the naming pattern used on the rack labels.

A vendor reading real samples can raise the gaps they reveal before the estimate, rather than during the build.

Mark what is not yet decided

Unknown values are normal at RFP stage. Mark them TBR with an owner and a date, as NASA’s appendix recommends, rather than leaving them out or inventing a number. A vendor can price a range for a TBR; it cannot price a requirement that is missing.

Tracing each requirement to UAT

Traceability means every requirement links forward to the tests that prove it, and every test links back to a requirement. NASA’s checklist asks that requirements be “bidirectionally traceable” to higher-level requirements; apply the same discipline downward to tests. In a warehouse project the practical form is a matrix with one row per requirement.

A requirements traceability matrix, from requirement to UAT result
Req IDRequirement (short)Acceptance testsUAT caseResultDefect
REC-014Match scanned SSCC to open ASNAT-014-1 to AT-014-7UAT-REC-03PassNone
PCK-022Short pick: reason, redirect, count taskAT-022-1 to AT-022-6UAT-PCK-05FailDEF-118: balance adjusted before count
LOT-007Capture lot and expiry, hold short-datedAT-007-1 to AT-007-8UAT-REC-04PassNone
NFR-01Scan response 1.0 s at 95%AT-N01-1 (load test)UAT-PERF-01Pass, 0.7 s at 95%None
NFR-02Offline queue for pick confirmationsAT-N02-1 to AT-N02-3UAT-PCK-09Not runBlocked: test Wi-Fi zone not ready
Fictional example data for illustration. IDs follow the requirement cards in this field note.

What the matrix catches

Read the matrix in both directions before UAT starts:

  • A requirement with no test will not be proven. Write the test or remove the requirement.
  • A test with no requirement is either testing something nobody asked for, or exposing a missing requirement. Find out which.
  • A requirement whose only test is the normal path has untested exceptions. Count the exception rows on its card.
  • A “Not run” at sign-off is an open risk, not a pass. Record who accepted it.

From acceptance tests to UAT scripts

Acceptance tests prove one requirement each. UAT scripts follow a day in the warehouse, so one script often covers several requirements: receive a pallet, put it away, pick it, ship it. Keep both, and link them. The UAT test plan template gives a structure for the scripts, the testers and the sign-off.

Keep the matrix alive after go-live

Requirements change after go-live, and the matrix is how you know what a change touches. When a requirement changes, its tests change with it, and the regression set grows. A current matrix answers “what do we retest for this release?” with a filter instead of a meeting.

Reviewing requirements before sign-off

A requirements review is a structured read against a checklist, with the people who do the work in the room. Run it before a document goes to vendors or developers, because a defect fixed on paper needs no rebuild and no retest.

A review checklist

Adapted from NASA’s validation checklist and the anatomy above, each requirement should pass these checks:

  1. It has one subject and one “shall”.
  2. It has a unique ID and a one-line rationale.
  3. Actor, trigger, data and rule are all stated.
  4. Every exception the floor can name has a row and a test.
  5. Numbers have units, conditions and a measuring point.
  6. It contains none of the unverifiable words listed earlier.
  7. It says what the system must do, not how to build it.
  8. A verification method is named.
  9. Every TBR has an owner and a date.

NASA’s appendix makes point 7 directly: “Requirements should state WHAT is needed, NOT HOW to provide it”. A requirement that names a screen layout or a database table limits the vendor’s options without adding a test.

Who should be in the review

  • The process owner, who settles disagreements about how the work should be done.
  • One person from each shift that does the work, because exceptions differ by shift.
  • The IT lead or integration owner, for interfaces and data.
  • A tester, who reads every requirement asking, “How would I fail this?”
  • Finance or inventory control, for any requirement that changes stock or cost.

Tolerances that are too tight

NASA’s checklist also asks: “Are the tolerances overly tight?” A one-second scan target at 99% may cost much more than the same target at 95%. Ask what would happen if the value were doubled. If the floor would not notice, relax it before a vendor prices it.

Signs a requirements document is not ready

  • Requirements describe today’s screens rather than the work.
  • Exception rows are empty or say “to be handled”.
  • Volumes are missing, or given only as annual totals with no peak day.
  • Several requirements share one ID, or IDs were renumbered after review.
  • Nobody from the night shift has read it.

What to do next

Start with one process area and five requirements, written in full, before you write fifty thin ones. The format will settle quickly, and the rest of the document will go faster.

  • Pick one process (receiving is a good first choice) and list every exception the floor can name.
  • Write each requirement on a card with ID, statement, rationale, actor, trigger, data, rule, exceptions and verification method.
  • Write a given, when, then test for the normal path and for every exception.
  • Put numbers, units, conditions and a measuring point on every non-functional requirement.
  • Add a context section with volumes, sites, devices, interfaces, labels, data counts and scope exclusions.
  • Start the traceability matrix now, with one row per requirement.
  • Review with the process owner, each shift, IT and a tester before anything goes to a vendor.

The software requirements checklist lists the areas a warehouse or tracking specification should cover, so you can see what is missing. If you want the process walk and the requirements written with you, our requirements analysis page describes how that work runs and what you receive.

Working on this problem?

If this field note describes a process you need to fix or build software around, tell us about it. We start with your process, your systems and your deadline.