How a GenFrontier engagement works
Every engagement runs through the same six stages. Each stage ends with a document or a working result that your team reviews and signs before the next one starts.
Start with a process walk
A tracking or inventory project touches the dock, the office and every system in between. We run each engagement in six stages so that nothing is built before the requirements are agreed, and nothing goes live without a tested cutover and a trained team. Each stage ends with something concrete that your people review and sign. If a stage turns up a reason to stop or change course, that is the cheapest point to find it.
The six stages at a glance
| Stage | What happens | Who takes part from your side | What you sign off |
|---|---|---|---|
| 1. Walk the process | We watch the work, collect documents and exports, and list every interface | Process owner, area leads, an IT contact | Current-state process map and integration inventory |
| 2. Write the requirements | Numbered requirements, each with an acceptance test | Process owner, area leads, IT lead | Requirements specification |
| 3. Plan the project | Phases, dates, owners, test windows and a cutover date | Project sponsor, process owner, IT lead | Project plan and the statement of work for the build |
| 4. Build and integrate | Software and interfaces built in short increments and shown at demos | Area leads at demos, IT for environments and access | Acceptance of each increment |
| 5. Test and cut over | User acceptance testing, a cutover rehearsal and go-live | Testers from each area, IT, sponsor | UAT results and the go or no-go decision |
| 6. Document and onboard | Guides, SOPs, runbook, role-based training and support handover | Trainees, supervisors, the support owner | Handover checklist |
Stage 1: Walk the process
We start where the work happens: on the dock, in the aisles and at the desks where purchase orders and carrier bookings are keyed. Where a site visit is not practical, a receiver or supervisor carries a phone or tablet through the process on a video call. A walk usually takes about half a day per area.
During the walk and the interviews that follow we record each step, who does it, with what device, and what they write down. We collect sample purchase orders, advance ship notices, labels, bills of lading and inventory exports. We ask about an ordinary day and a peak day, and about the exceptions: short shipments, damaged cartons, unlabeled pallets, late carriers.
The output is a current-state process map with the pain points marked, and an integration inventory that lists every interface between your ERP, WMS, TMS, carriers and trading partners, including the ones done by hand. The process owner signs off that the map shows how the work is done today, not how the manual says it should be done.
Stage 2: Write the requirements
Each requirement is one numbered statement of what the system must do, written so it can pass or fail. Each has an acceptance test that names the data to use and the result to expect. The document also lists what is out of scope and the open questions, each with an owner.
We hold review sessions with the people who will use the system, revise, and ask the process owner and IT lead to sign. Disagreements about how work should be done are settled here, on paper, by the person you named to settle them. See requirements analysis for what the document contains.
Stage 3: Plan the project
The plan turns signed requirements into phases with dates, owners on both sides, test windows and a cutover date that avoids your peak season. We order the work so the first increment is small and useful: one dock, one lane, one site or one count program. The plan names dependencies we do not control, such as a test environment, trading partner EDI specifications or a carrier API account.
With the plan comes an estimate and a statement of work for the build. Your sponsor signs both before any build starts. If you bought the Scope and plan engagement on its own, the work ends here and the documents are yours to use with us or anyone else. More detail is on the project planning page.
Stage 4: Build and integrate
We build in short increments. Each one ends with a demo on your test data, attended by the people who will use the screens, not only by IT. At the demo you accept the increment or we log what has to change.
Interfaces are built to what your systems and partners support: APIs, X12 EDI messages or scheduled files. The ERP, WMS and EDI integration page describes that work. All building and testing happens in a test environment with masked sample data, as described on our security page. Documentation and training material are drafted alongside the build so they describe the real screens.
Stage 5: Test and cut over
Your users run user acceptance testing from a UAT plan built from the stage 2 acceptance tests. Defects are logged with a severity, fixed and retested. The stage passes when the agreed tests pass, not when a date arrives.
The cutover plan covers data loads, open purchase orders and shipments in flight, the order in which interfaces are switched on, rollback criteria, and who is on the floor for the first shifts. We rehearse it in the test environment. The sponsor makes the go or no-go call at a short meeting, using the go-live readiness checklist.
Stage 6: Document and onboard
Documentation is finished against the system as it went live: an admin guide, user guides, SOPs for each role, and an integration runbook that says what to check when a message fails. Role-based training runs before cutover on the test system, with short refreshers in the first days after. The stage closes when the handover checklist is signed: documents delivered, source code and configuration delivered, open issues listed with owners, and support arrangements agreed.
From there you can run the system yourselves or continue with a Support after go-live engagement. The documentation and onboarding and training pages describe these deliverables in full.
How change requests are handled
Requirements change once people see working software. That is normal, and we handle it in writing:
- Anyone on either team can raise a change request. It states what should change, why, and which requirements it touches.
- We assess the effect on scope, dates and cost and send it back in writing.
- Your sponsor approves or declines. Nothing is built until it is approved.
- Approved changes update the requirements, the plan and, where needed, the statement of work.
Clarifications that do not change scope, such as a field label or a report column order, are recorded in the decision log rather than run as change requests.
Communication and demos
- One named contact on each side, so decisions do not get lost between inboxes.
- A written status note every week: what was done, what is next, risks, and decisions we need from you.
- A shared decision log and issue log that both teams can read at any time.
- Demos at the end of every increment, on your test data, with time for the people on the floor to try the screens.
- Documents kept in your systems where possible, so nothing important lives only in our files.
To see the stages applied to one invented project, read the fictional example project.
Scope your project.
Tell us what you need to track, which systems you run and when it has to work. We reply with questions or a time to talk.