Implementation Approach | ServiceCPQ
Implementation Approach

From Discovery to Deployment — A Structured Path to Value

ServiceCPQ follows a pragmatic, iterative implementation methodology — starting with what works out of the box, then collaboratively closing gaps, training models, and deploying with confidence.

Structured Phases AWS · Client Cloud · On-Premise AI Model Training & RAG Dev → Acceptance → Prod
Implementation Phases

Seven Phases to a Production-Ready Platform

Each phase builds on the last. We start by proving value with the standard platform, then close gaps systematically — so you know exactly what you're getting before customisation begins.

1

We start by mapping your current state — how opportunities are found, how quotes are built, how contracts are priced, and what data exists in your ERP and CRM. This gives us a shared baseline before any configuration begins.

What We Cover

  • Current aftermarket sales process mapping — opportunity to quote to order
  • ERP and CRM landscape: systems, versions, API readiness
  • Installed base data quality assessment
  • Existing pricing models, contract structures, BOM hierarchy
  • Stakeholder interviews — sales, service, IT, finance

Outputs & Deliverables

  • As-is process map and gap summary
  • Data readiness assessment for each integration source
  • Integration architecture blueprint (ERP + CRM)
  • Implementation scope and phasing recommendation
  • Initial must/should/nice-to-have requirements list
Outcome: Shared understanding of what ServiceCPQ will deliver, what integration is needed, and where customisation will be required — agreed before any build begins.
2

We configure the standard ServiceCPQ platform using your real data — equipment models, parts catalogues, job libraries, pricing rules, and contract templates. The goal is to show you exactly what works out of the box before any customisation is discussed.

What We Build

  • Commercial Engine configured with your installed base data
  • CPQ templates for PM contracts, repair quotes, parts agreements
  • Job library, maintenance kits, and standard BOM structures
  • ERP and CRM integration connections (sandbox environment)
  • Pricing rules, margin guardrails, and discount tiers configured

Validation Activities

  • Walk through 3–5 real customer scenarios end-to-end
  • Verify data flows from ERP through to CPQ output
  • Review opportunity detection accuracy against known gaps
  • Validate LCC model outputs against historical contracts
  • Stakeholder demo and feedback collection
Outcome: A working, configured platform running against your real data. Clear visibility of what already works — and a documented list of what is missing or needs adaptation.
3

After seeing the base model, every client identifies requirements that aren't yet met out of the box. We run a structured prioritisation workshop to classify each gap — deciding what gets built, what gets added to our product roadmap, and what can wait.

How We Prioritise

  • Structured workshop with sales, service, and IT leads
  • Each gap assessed: business impact, implementation effort, frequency of use
  • Must Haves: block go-live — will be customised in Phase 4
  • Should Haves: reviewed for product roadmap inclusion
  • Nice to Haves: deferred to future iteration cycles

Product Roadmap Discussion

  • Should Haves reviewed by our product team
  • Assessment: does this add value for other clients too?
  • If yes → added to product roadmap, delivered as standard feature
  • If no → scoped as client-specific customisation
  • Transparent timeline commitment on roadmap items
Outcome: A prioritised gap register with agreed actions. No surprises — you know exactly what will be built, what goes on the roadmap, and what is deferred before Phase 4 begins.
4

Must Have gaps are built in focused sprints — custom workflows, ERP adapter extensions, bespoke pricing rules, and any industry-specific configurations. Each customisation is documented, tested, and peer-reviewed before integration into the platform.

Typical Customisations

  • Custom ERP integration endpoints or data mapping rules
  • Industry-specific contract structures or pricing logic
  • Bespoke approval workflows or dealer permission models
  • Custom BOM compatibility rules for specialist equipment
  • Client-specific reporting or dashboard views

Delivery Process

  • 2-week sprints with fortnightly client reviews
  • Each item spec'd, built, and unit tested before demo
  • Client UAT after each sprint — no black-box delivery
  • Full documentation of every customisation
  • Regression testing on base platform after each change
Outcome: All Must Have gaps resolved. Platform ready for data loading and model training. Client has reviewed and signed off every customised item.
5

With the platform configured and customised, we load your full production dataset and train the AI models against your real equipment, customer, and service history data. Infrastructure is provisioned on AWS, client cloud, or hybrid — according to your preference and security requirements.

Data Loading

  • Full ERP master data extraction and load (equipment BOM, customers, prices)
  • Historical quote and contract data ingestion for model training
  • Service history records to train propensity and LCC models
  • Parts usage history for demand and recommendation models
  • Data validation, deduplication, and quality scoring

Model Training & AI Setup

  • Propensity model training — scored against your customer base
  • RAG (Retrieval-Augmented Generation) configured for job libraries and technical docs
  • LCC model parameter tuning to match your cost structure
  • Parts recommendation algorithm training on usage patterns
  • Algorithm performance benchmarking and tuning cycles
Cloud Infrastructure Options
ServiceCPQ AWS Client AWS Account Azure / GCP Private Cloud / Hybrid
Outcome: Platform running on production data with trained models. Propensity scores, LCC parameters, and recommendation algorithms calibrated to your specific equipment, customer base, and pricing structure.
6

Before any production deployment, the fully configured and trained platform runs through structured testing in a dev environment — covering integration flows, UI workflows, model accuracy, and edge cases. Client teams conduct formal User Acceptance Testing (UAT) against agreed test scripts.

Testing Coverage

  • Integration tests — all ERP and CRM flows end-to-end
  • CPQ workflow testing — opportunity to quote to order
  • Model accuracy review — propensity scoring, LCC outputs
  • Performance testing under load (concurrent users)
  • Security and access control verification

UAT & Sign-Off

  • Client teams run agreed UAT test scripts against dev environment
  • Defects triaged by severity — critical, major, minor
  • Critical defects resolved before go-live gate
  • Formal UAT sign-off from client project sponsor
  • Go-live checklist completed and approved
Outcome: Formal UAT sign-off achieved. Zero critical defects. Production deployment approved by both teams.
7

Production deployment is a managed cutover with hypercare support. Once live, we enter a continuous improvement cycle — monitoring model performance, retraining on new data, delivering Should Have features, and iterating based on real user feedback.

Go-Live & Hypercare

  • Managed production cutover with rollback plan
  • 30-day hypercare period — dedicated support response
  • Daily performance monitoring — model accuracy, API health
  • User adoption tracking and coaching sessions
  • Integration health dashboards for IT team

Continuous Improvement

  • Monthly model retraining as new quote and service data accumulates
  • Algorithm parameter tuning based on win/loss outcomes
  • Should Have features delivered from product roadmap
  • Quarterly business reviews — ROI measurement, next priorities
  • Expand to new regions, product lines, or dealer networks
Outcome: A live, improving platform — not a one-time deployment. Models get smarter with every quote. Coverage expands with every iteration cycle.
Gap Framework

Must Have · Should Have · Nice to Have

Not all gaps are equal. Our prioritisation framework ensures the right requirements are addressed at the right time — without over-engineering or scope creep.

Must Have

Will Customise

Requirements without which the platform cannot meet core business needs. These block go-live and must be resolved in Phase 4 before production deployment.

→ Customisation built in Phase 4
  • Industry-specific contract structures not in standard templates
  • Custom ERP data mappings or non-standard API responses
  • Bespoke approval workflows required by internal compliance
  • Specific pricing logic unique to your commercial model
Should Have

Product Roadmap Review

Valuable requirements that don't block go-live but significantly improve the experience. We assess whether adding them to our product benefits all clients — if yes, they ship as standard features.

→ Product team reviews for roadmap inclusion
  • New CPQ workflow pattern with broad industry applicability
  • Additional ERP connector for a widely used system
  • Enhanced reporting or dashboard view useful across segments
  • UX improvement that benefits all users, not just one client
Nice to Have

Deferred to Iteration

Useful but non-critical features that would improve efficiency or convenience without affecting core outcomes. Deferred to post-go-live iteration cycles once the platform is live and stable.

→ Added to post-go-live iteration backlog
  • Additional UI customisations or branding preferences
  • Advanced analytics or niche reporting views
  • Convenience automations for edge-case scenarios
  • Future integration with secondary systems (phase 2+)
Infrastructure

Flexible Deployment — Your Cloud or Ours

ServiceCPQ deploys on the infrastructure that meets your security, data residency, and cost requirements.

ServiceCPQ AWS

Managed by our team on AWS. Fastest to deploy. Multi-tenant with full data isolation. SLA-backed uptime.

Client AWS Account

Deployed into your own AWS account. You own the infrastructure. Ideal for data residency or compliance requirements.

Azure / GCP

Container-based deployment on Azure AKS or Google GKE. For clients with existing Azure or GCP enterprise agreements.

Private / Hybrid

On-premise or hybrid deployment for air-gapped environments. API-compatible with ServiceCPQ cloud for sync scenarios.

Ready to Start

Begin Your Discovery Session —
See What's Possible in Week One

Most clients are running against their real data within two weeks of kick-off. Let's start with discovery and show you what the base platform delivers out of the box.