Home/Approach

How an engagement runs, phase by phase.

Every engagement runs in five phase-gated stages: discovery, solution design, implementation, UAT and training, and sign-off with hypercare. Each phase ends with documents you review and approve before the next one starts, so you can see the scope, the progress and the technical decisions at every step.

01
Phase / Discovery
1–2 weeks
Business process engineering

Processes mapped as they run, not as they're documented.

We break down each business process in scope, end to end, as it runs today rather than as the SOP describes it. Interviews with the people who run it turn up undocumented logic, manual workarounds and upstream dependencies. The result is a current-state model we design against, with every assumption written down before anyone writes code.

Activities
  • Stakeholder interviews (5–8 roles)
  • Current-state process decomposition
  • SuiteScript & workflow inventory
  • Data model & schema analysis
  • Integration touchpoint mapping
  • Risk & constraint inventory
Deliverables
  • As-run process maps
  • Technical debt inventory
  • Prioritized requirements backlog
  • Effort & complexity estimates
02
Phase / Solution design
2–4 weeks
Design and sign-off

Full technical spec, signed off before build.

The design phase produces a technical specification. It covers data model changes, SuiteScript architecture, integration contracts, roles and permissions, and the UAT acceptance criteria. The people who own each process review and approve every decision, so the scope is settled before the first sprint.

We specify
  • Target-state process architecture
  • Data model & schema changes
  • SuiteScript module specification
  • Integration contracts & API endpoints
  • Role & permission architecture
  • UAT strategy & acceptance criteria
Deliverables
  • Technical solution design document
  • Sprint-level build estimates
  • Stakeholder sign-off record
  • Go-live readiness criteria
03
Phase / Implementation
2–6 months
Development & build

Configured, coded, and deployed sprint by sprint.

Implementation runs in two-week sprints, with a demo every week and a sandbox deployment every Friday. Every build item traces to the specification signed off in phase 02, so nothing gets built that was not agreed. We write the code in SuiteScript 2.1, and it is peer-reviewed before it reaches your account.

Development activities
  • Sprint planning & backlog grooming
  • SuiteScript 2.1 development
  • SDF-versioned deployments
  • Integration build & endpoint testing
  • Configuration & workflow automation
  • Weekly demo & sandbox release
Deliverables
  • Tested, deployed software
  • Full SDF source repository
  • Technical documentation
  • Defect log & resolution record

See the work we have shipped

04
Phase / UAT and training
2–4 weeks
Walkthrough & validation

User acceptance, scenario by scenario.

UAT follows the acceptance criteria agreed in phase 02. Each process owner runs scripted test scenarios and records a pass or a fail against an agreed threshold. We run training by role and record it, so people who join later can watch the same sessions.

Activities
  • Scripted UAT against acceptance criteria
  • Process walkthrough per business role
  • Defect triage & resolution sprints
  • Role-specific training sessions
  • Recorded demo library
  • Go-live readiness sign-off
Deliverables
  • Signed UAT completion record
  • Role-based training materials
  • Recorded session library
  • Go / no-go decision brief
05
Phase / Sign-off and hypercare
2–4 weeks post go-live
Go-live & stabilisation

Live in production, supported through stabilisation.

Go-live starts a stabilisation window. During hypercare a senior consultant is on hand for priority issues, configuration changes and production monitoring while your team settles into the new system. Formal sign-off closes the engagement once every acceptance criterion is met in production.

Hypercare coverage
  • Priority issue response (same day)
  • Production monitoring & triage
  • Configuration adjustments
  • User support & coaching
  • Runbooks & SOPs handover
  • Architecture & data flow diagrams
Sign-off package
  • Formal acceptance sign-off
  • Source repo & CI/CD handover
  • Admin & developer documentation
  • Post-go-live recommendations brief

See managed support

Principles

Four rules we work by.

P / 01

Senior-led

Every engagement has a named senior consultant who is your contact from discovery to sign-off.

P / 02

Accountable for the result

We answer for the result you asked for, not for the hours logged. If we misjudge the scope, that is on us.

P / 03

Transparent

We put risks, trade-offs and mistakes in writing, so you know where the project stands at any point.

P / 04

Handover-ready

Everything we build is documented and versioned, and your team can take it over the day we hand it off.

Want to see how this runs in practice?

A 30-minute working session with a senior consultant. No slides and no pitch deck. We walk you through a past engagement and what from it would apply to yours.