By Raphael Schwirtlich · Published Mon Nov 09 2026
Case Study - Service Engine
This case study is a sample implementation of the RS Tech Hub Service Engine, built to demonstrate how the Revenue Engine framework applies across the lifecycle stages of a B2B service business — Sales & Evaluation (Catalog & Quoting), Onboarding (Contracting & Kickoff), Product Adoption (Delivery & Time Tracking), and Billing & Payments (Change Requests & Invoicing). It is not an engagement with an actual client. It walks through the catalog-to-cash lifecycle as it would run for a representative B2B service consultancy, and was designed and built by Raphael Schwirtlich end to end, from process design to engineering.
From Static Catalog to One Connected Quote-to-Cash System
Industry: B2B Software Consultancy (Fixed-Scope Projects, Retainers & T&M)
Company size: Small-to-mid consultancy, multiple concurrent client engagements
Engagement type: Sample implementation — internal reference build, not a client engagement
Deliverable: Service Catalog, Contract & Delivery Platform (Service Engine)
The Situation
A software consultancy selling fixed-scope projects, retainers, and hourly work to B2B clients was running its entire service business on disconnected tools. Proposals were drafted from whatever the last similar project looked like, with scope and pricing re-typed by hand each time. Contracts — master service agreements with per-project statements of work — were negotiated in one tool, signed in another, and tracked nowhere in particular. Once a deal closed, a project manager spent the better part of a day manually setting up the delivery plan from the quote, because nothing carried over automatically.
Time was logged loosely, if at all. Change requests were handled over email and folded into the project quietly, without anyone updating the budget or the plan. Invoicing happened on a rough monthly rhythm, disconnected from what had actually been delivered.
The consultancy was growing its client roster, but every new engagement added the same manual overhead, and nobody could say with confidence what a given project's real margin was until it was already over.
The Problem Diagnosis
Before any development began, the full quote-to-cash lifecycle was mapped. The analysis surfaced five compounding failure points:
- Catalog drift. There was no reusable, approved definition of what the consultancy actually sold. Every proposal was assembled from scratch, so scope and pricing drifted project to project, and nobody could quote confidently without re-deriving the plan.
- Contract fragmentation. Framework agreements and statements of work lived in separate tools with no formal link between them. There was no single model that could tell you which SOWs were running under which MSA, or what terms applied by default.
- No signature-to-kickoff path. A signed contract carried no structured link to a delivery plan. Translating a quote into a working project plan was a manual, hours-long exercise performed by a project manager for every single engagement.
- Undisciplined time tracking. Hours were logged against projects, not against the specific piece of work in progress. There was no enforced link between time, milestone status, and what had actually been invoiced — so margin was only ever known in hindsight.
- Change requests without a system. Scope changes were agreed informally and absorbed into the project. Budget, timeline, and invoicing were rarely adjusted to match, which is exactly where service margins quietly disappear.
The root cause was consistent across all five: the business had a sales process and a delivery process, but no engineered connection between them. Everything that crossed that boundary depended on someone remembering to carry it across correctly.
The Approach
The project began with process design, not software. The full lifecycle — catalog, quote, contract, delivery, time, change request, invoice — was mapped as a single connected model before any schema was written.
A service catalog was designed around reusable templates: each one carrying a description, acceptance criteria, an ordered set of milestones with estimated effort, and a linked price, moving through a Draft → Template review flow before it could be quoted. Quotes were designed to be assembled from that catalog rather than typed by hand, so a quote line's description and effort always traced back to an approved service definition.
Contracts were modelled as one type with variants — Framework Agreement, Statement of Work, NDA, Amendment — so an SOW could inherit terms from an MSA or stand alone, and a single SOW could combine a fixed-price milestone project with an hourly item under one signature. Signature was designed as the trigger: on signing, every quoted service becomes a customer-specific instance with its own milestone plan, and a delivery engagement opens automatically, with no manual re-entry.
Time tracking was constrained by design — an entry can only be booked against a milestone that is actually in progress, and only becomes billable once it has gone through a submit → approve → reject workflow. Change requests were modelled as formal, reviewable records that adjust budget, hours, and timeline on approval, and invoicing was wired to trigger from delivery events rather than a calendar reminder.
What Was Built
Sell A reusable service catalog with templated milestones and effort estimates, gated by a Draft → Template review flow. Quotes are generated from catalog services rather than typed by hand, and tailoring a template for a customer automatically recalculates the effort budget and price.
Contract One contract model covering Framework Agreements, Statements of Work, NDAs, and Amendments, with a single SOW able to combine a fixed-price milestone project and an hourly item under one signature. On signature, every quoted service becomes a customer-specific instance, and a delivery engagement opens automatically — nothing re-keyed between sales and delivery.
Deliver Delivery engagements track milestones with due dates, estimated versus tracked hours, and optional client sign-off, alongside health status, satisfaction score, and escalation flags. Time can only be logged against milestones actually in progress, and a submit → approve/reject → invoice workflow rolls approved hours up to the milestone, engagement, and service totals automatically.
Operate Change requests are raised, reviewed, and approved formally, with budget, hours, and timeline adjusting automatically on approval and changes with commercial impact passed to billing without a manual step. Invoices trigger from delivery events across five billing models — per service, per milestone, hourly, monthly, or fixed price — with every invoice recorded against the agreement, service, and milestone it covers. A daily scheduler monitors every agreement's delivery dates so renewals and deadlines don't slip unnoticed.
The Outcome
The sample implementation demonstrates a consultancy that moved from a sales process and a delivery process held together by memory, to one connected system.
The illustrated results:
- Quoting runs from an approved catalog instead of a blank document — scope and pricing stay consistent project to project.
- Signature triggers delivery automatically: a customer-specific milestone plan and a live delivery engagement exist the moment a contract is signed, with nothing re-entered by hand.
- Time can only be logged against work actually in progress, and approved hours roll up to milestone, engagement, and service totals without a manual reconciliation step.
- Change requests update budget, timeline, and billing together, so scope creep shows up in the numbers instead of eroding margin silently.
- Invoicing follows what delivery actually confirms, with a complete trail back to the agreement and milestone it covers — margin is visible mid-project, not discovered after it closes.
The consultancy's growth is no longer limited by how many project managers it can put on manual handovers between sales and delivery.
The Principle Behind the Work
Service margins are not lost because consultants work carelessly. They disappear in the handovers — between the proposal and the contract, the contract and the project plan, the work done and the invoice sent — where nothing enforces that scope, time, and money stay in sync.
When catalog, contract, delivery, and billing run on one connected model, those handovers close themselves. When they run on separate tools and someone's memory, every handover is a chance for the number to drift.
This sample implementation applies that principle directly: diagnose where the quote-to-cash lifecycle breaks, engineer the connections, and let the system — not individual discipline — keep scope, delivery, and billing in sync.
This case study is a sample implementation, not an engagement with an actual client. It illustrates how the Service Engine's catalog-to-cash lifecycle applies to a representative B2B service business. All described functionality reflects capabilities built and demonstrated as part of the Service Engine product.