MSP software built for how your service desk actually runs
Custom software for managed service providers: multi-tenant ticketing, PSA/RMM integrations, SLA enforcement, and recurring-revenue billing, engineered around your contracts, your clients, and your margins.
Off-the-shelf PSA and RMM platforms are powerful but opinionated. We build the integrations, the billing logic, and the client-facing layers they don't cover. Or the purpose-built platform that replaces the five-console sprawl entirely.
Multi-tenant ticketing with real client isolation: tenant-scoped data, SSO, and audit trails
PSA/RMM integrations: ConnectWise, Autotask, NinjaOne, with REST APIs, webhooks, two-way sync
SLA engine: response and resolution timers enforced per contract, with escalation chains
Recurring-revenue billing: MRR contracts, block hours, T&M, and per-device lines on one invoice
Migration without losing history: tickets, clients, contracts, and assets moved intact
The problem
Sound familiar?
Your techs alt-tab between five consoles to close one ticket. Every tool carries a license cost, an admin cost, an onboarding cost for every new hire, and an integration that breaks quietly, and the last three show up as hours nobody bills?
Your PSA is "more than you need and not very user friendly," in the words of one small MSP shopping for a replacement: heavy, overkill for your size, and searching tickets feels like archaeology?
Short answer
RaftLabs builds custom MSP software for managed service providers: multi-tenant ticketing, PSA/RMM integrations, SLA engines, and recurring-revenue billing. A focused tool typically runs $55K to $110K over 16 to 20 weeks. We scope every project before pricing. Fixed cost, agreed before work starts.
Who this is for
MSPs we build for
Growing MSPs
Ticketing, SLA engines, and billing built around your contract mix, not a platform's assumptions.
Multi-tenant service operators
Client data truly isolated, with technician time back on billable work.
MSPs selling products
Client portals and white-label offerings that become revenue lines.
Compliance-bound MSPs
HIPAA-ready audit trails and evidence for regulated clients.
01 Diagnosis
Problems we solve for MSPs
- 01Problem
Tool sprawl is eating your margin, and the reconciliation lands on billable tech time
CostThe RMM watches devices. The PSA holds tickets. Documentation lives in IT Glue or Hudu. Billing runs in QuickBooks. Licenses reconcile in a spreadsheet. None of them agree on what a 'client' is, so your senior tech spends Friday afternoon reconciling asset counts against invoices instead of doing billable work.
SolutionThe fix isn't always fewer tools. Sometimes it's the integration layer that makes them behave as one: asset sync that prevents duplicate records, two-way ticket/alert sync, and time entries that flow into billing without re-entry.
- 02Problem
Your PSA holds years of contract logic that no migration template understands
CostThis is why MSPs stay on platforms they've outgrown. The PSA contains custom statuses, contract-specific billing rules, and workflow automations built up over years, and every migration guide assumes you're moving to the vendor's happy path (the standard route the vendor expects you to follow). On a Spiceworks thread from a small MSP replacing ConnectWise Manage, the buyer's verdict was blunt (Spiceworks, Feb 2022). Manage was 'more than we need and not very user friendly in terms of searching tickets, reporting etc. It feels very heavy/overkill for a company our size'.
SolutionWhether we build you a new platform or a better integration layer, migration is engineered, not hoped for: ticket history, client records, contract terms, and asset data mapped field by field, with a parallel-run period (running the old and new systems side by side) before cutover.
- 03Problem
Alerts fire in the RMM and die there: no ticket, no time entry, no invoice
CostThe monitoring is working; the business process isn't. An alert fires at 2 AM, a tech remotes in and fixes it, and nothing is recorded: no ticket for the client to see, no time entry against the contract, no record for the QBR (quarterly business review).
SolutionThe industry's standard eval tip says it plainly: check whether the integration supports two-way sync, so closing the ticket closes the alert in the security console and vice versa (ToolsInfo, 2026). We build alert-to-ticket pipelines with the sync rules your SLAs (service-level agreements, the response times promised in the contract) require: deduplication (removing duplicate alerts), severity mapping (sorting alerts by how urgent they are), auto-assignment, and time capture from the moment of remediation (when the tech starts fixing it).
- 04Problem
SLAs live in a spreadsheet while the contract promises 15-minute response
CostThe contract says P1 response in 15 minutes. The spreadsheet says… nothing, because nobody updates it during an outage. Managed-services billing has to price recurring contracts, enforce SLA commitments, bill break-fix work (one-off repair work), and carry hardware resale margin at once, which is why generic systems rarely fit without heavy add-ons (ERP Research, 2026).
SolutionSLA enforcement has to be a system property (built into the system, not tracked by hand). Timers start when the ticket is created, pause conditions are defined (waiting on client, waiting on vendor), and escalation chains fire automatically when thresholds breach (when a time limit is passed and the ticket moves up to the next level). Every timer event is logged for the invoice dispute that comes later.
02 What we ship
What we build
Multi-tenant ticketing & service desk
Ticketing engineered for the MSP model: every ticket, asset, note, and invoice scoped to a client tenant at the data layer, not just filtered in the UI. Client portals with ticket status, quote approvals, and knowledge base, so "is my laptop ready?" stops interrupting your techs. Co-managed IT support with security segmentation: the client's internal IT works tickets alongside your team but sees only their company. Per-client SSO/SAML, role-based access, and full audit trails throughout.
PSA & RMM integrations
Integration with the platforms you already run: ConnectWise PSA, Datto Autotask PSA, and NinjaOne via their REST APIs, with webhook-driven two-way sync: alerts become tickets, ticket closures resolve alerts, asset changes sync to documentation. Time entries flow into the PSA's billing queue without re-entry. Where a vendor exposes only file exports or no API at all, we build the ingestion pipeline instead of promising magic. Integration scope is always defined during discovery, because feasibility depends on the specific system and version.
Contract & recurring-revenue billing engine
The billing layer most PSAs approximate, and none get exactly right for your shop, handles recurring MRR agreements, prepaid block hours with automatic drawdown and low-balance alerts, T&M with per-role rates, and per-device or per-user lines. Everything merges onto a single invoice per client per cycle. License reconciliation against distributors like Pax8 and Microsoft 365, so billed seats match provisioned seats. Sync to QuickBooks Online/Desktop or Xero for the general ledger. Syncro's published 2026 list pricing runs roughly $129–$179 per technician per month, which we use when modeling your build-vs-buy math against real numbers, not feature lists.
SLA management & escalation
SLA policies defined per contract and per priority: response and resolution timers, business-hours calendars per client, pause conditions, and escalation chains that page the right tier automatically. Timer events are immutable and logged: the record you need when a client disputes an invoice or a QBR needs SLA attainment numbers. Real-time dashboards show at-risk tickets before they breach, not after.
Onboarding, migration & documentation sync
New-client onboarding as a workflow, not a project: standardized intake, asset discovery import, M365 tenant sync, and documentation provisioning in IT Glue or Hudu with asset matching that avoids duplicate records. Migration from ConnectWise, Autotask, or Zendesk maps tickets, clients, contracts, and configuration items field by field, validated in a staging tenant before cutover. The industry's best advice for choosing a PSA applies equally to building one: run your real tickets, a real billing cycle, and real client data through the system before you commit (Gorelo, 2026). We build that trial into the process.
Reporting: margin, utilization & QBR-ready dashboards
The reports that run the business: per-client profitability (contract revenue vs. ticket time vs. license cost), technician utilization, SLA attainment by client and priority, ticket volume trends, and license reconciliation. QBR-ready client summaries generated from live data: ticket stats, project status, security posture, upcoming renewals, instead of assembled by hand the night before. Power BI-compatible data models where you want your own analytics on top.
Integrations
One layer over the stack you already run
PSA, RMM, accounting, and licensing data reconcile in the layer your techs actually work in.
- PSA and RMM
- ConnectWise · Autotask · NinjaOne
- Billing
- QuickBooks · Xero · Pax8 license reconciliation
03 Buy, build, or wait
Stay on the platform while your contracts fit its assumptions.
The MSP software question is really about whether your contracts and stack are standard enough for an off-the-shelf PSA or specific enough to need your own layer.
Buy or rent
ConnectWise or Autotask, for standard contracts
Buying wins when your billing model and SLAs fit the platform's assumptions and your techs can live inside it.
Wait, while the stack holds
Waiting wins when five consoles are annoying but the Friday reconciliation still fits in an afternoon.
Build custom
When billing does not map
Your contract mix, block hours, or per-device lines fit no platform's billing model.
When techs alt-tab for a living
Reconciliation across five tools lands on billable technician time every week.
When the portal is a revenue line
A client-facing portal or white-label product is itself something you can sell.
Bottom line
Stay on the platform while your contracts fit its assumptions. Build when your billing model, SLAs, or integrations do not map to anything the platform assumes.
04 How we work
How we work with MSPs
- Step 0101
Discovery
We spend the first two weeks inside your operation. We map how tickets flow from alert or client call to invoice, what your contract types actually look like (not what the brochure says), where the billing leaks are, and which integrations your techs rely on. We interview the service manager, the dispatcher, and at least two technicians: the people who live in the tools. The output is a documented requirements list, an integration map of your current stack, and a gap analysis. We build what your service desk actually needs, not a generic PSA template.
- Step 0202
Architecture
We design the tenant model, the contract and billing data model, and the SLA timer semantics before writing any application code. This step defines how client isolation is enforced, how each contract type bills, which systems integrate via API vs. ingestion pipeline, and what the migration field-mapping looks like. You review and sign off on the architecture document before development begins, including the threat model for client data segregation.
- Step 0303
Build
Development runs in two-week sprints with a working demo at the end of every sprint, tested against your real ticket shapes and contract types. We start with the multi-tenant ticketing and data layer, then build the billing engine against your actual contracts, then the PSA/RMM integrations, then portals and reporting. You test with real (anonymized where needed) data as each module completes. The Gorelo rule: real tickets, a real billing cycle, real client data before you commit.
- Step 0404
Launch and support
Go-live is phased: one client cohort or one service team runs on the new system in parallel with the existing stack. When ticket counts, time entries, and invoice totals reconcile, the rest of the operation cuts over. We monitor the first month actively, resolve production issues found during the go-live period, and hand over documentation plus runbooks your team can actually operate. Post-launch changes (new contract types, new integrations, new reports) are quoted and agreed as discrete pieces of work.
05 Track record
- Typical focused MSP tool v1
- 16-20 wks
- Client isolation from day one
- Multi-tenant
- Cost, agreed before we start
- Fixed
- Shipping production software
- Since 2015
08 Why us
Why choose us?
- 01
Billing modeled on your contracts
Recurring agreements, block hours, and per-device lines merge onto one invoice per client per cycle, because no platform's billing model maps to yours. - 02
Techs stop alt-tabbing for a living
Reconciliation across five consoles lands in one layer, so billable technician time goes back to clients. - 03
Migration without losing history
Moving off ConnectWise or Autotask keeps tickets, contracts, and documentation history intact.
Frequently asked questions
Straight answers to what buyers ask before they scope. Still stuck? .
Buy when a standard platform fits your contracts and your techs can live inside it: the ecosystem, hiring pool, and third-party integrations of the incumbents are real advantages. Build when your billing model or SLA structure doesn't map to any platform's assumptions. When reconciliation across five tools lands on billable technician hours, build. A client-facing portal or white-label product that is itself a revenue line is another trigger, as is a PSA holding years of custom contract logic that no migration template understands. The community's shorthand from a widely-read Spiceworks thread still holds: all-in-one platforms do 80% of what you want 80% of the time at low cost; deep configurability costs more and needs an owner. Custom is the third option: exactly your workflows, with you as the owner.
Through their documented REST APIs plus webhooks. The standard pattern works like this. The RMM fires alerts via webhook, our integration layer deduplicates and maps severity, and creates or updates tickets in the PSA with the client/asset context attached. It syncs state both ways: closing the ticket resolves the alert, and resolving the alert updates the ticket. Asset inventories sync on a schedule with matching logic to avoid duplicate configuration items, and technician time entries flow into the PSA billing queue. Two-way sync is the eval criterion that matters most: one-way integrations create shadow records that drift. We define the exact sync semantics during discovery and don't commit to integrations for systems without documented APIs.
Yes. This is an architecture decision, not a feature flag. Every ticket, asset, document, time entry, and invoice carries a tenant identifier enforced at the data-access layer, so a query bug can't leak one client's data to another. Access control is role-based with per-client SSO/SAML, and co-managed setups get security segmentation so a client's internal IT staff see only their own company while your techs see everything they're assigned. All access is audit-logged. We design the tenant model up front and you sign off on it before build, because retrofitting isolation onto a single-tenant schema is a rewrite, not a patch.
As one data model, not three modules bolted together. Contracts define the commercial terms: MRR value, included hours or devices, per-role T&M rates, SLA tier. The SLA engine attaches timer policies to those contracts: response and resolution targets per priority, client business-hours calendars, pause conditions (waiting on client, waiting on vendor parts), and escalation chains. The billing engine then reads the same model: recurring charges, block-hour drawdown with low-balance alerts, T&M from approved time entries, and per-device lines, merged onto one invoice per client per cycle, synced to QuickBooks or Xero. Because SLAs, time, and billing share the model, an SLA credit or a disputed hour traces back to the timer events that produced it.
Yes, with engineering rather than hope. Migration maps tickets (with notes, attachments, and status history), companies and contacts, contract terms, configuration items, and knowledge base articles field by field into the new schema, validated in a staging tenant your team can click through before cutover. Ticket number continuity is preserved or mapped so old references still resolve. The cutover itself is phased: typically one service team or client cohort first, running in parallel until ticket counts, time entries, and invoice totals reconcile. What we don't do: lift-and-shift custom workflow automations one-to-one. Those get re-expressed in the new system's model during discovery, because the automation that made sense in the old platform rarely maps cleanly.
Yes. This comes up constantly: one widely-discussed Spiceworks thread had a small MSP whose clients were mostly HIPAA-bound, requiring any vendor with unattended access to sign a BAA. We build on infrastructure with executed BAA agreements, enforce encryption in transit and at rest, maintain immutable audit logs of all record access, and implement role-based access with least privilege. Remote access sessions are logged with technician identity and duration. We're not a HIPAA compliance consultancy. Your compliance team owns the administrative side, but the software provides the technical safeguards, and we sign BAAs as your sub-processor where the engagement requires it.
It depends on who you're selling to, and the math cuts both ways. Per-technician pricing with unlimited endpoints favors growth: landing a 400-seat client costs nothing extra in licenses until you hire, which is why it's popular with scaling MSPs. Per-endpoint pricing is cheaper for very small fleets but rises with every device you add, and it taxes your biggest wins. If you're productizing the tool for other MSPs, per-technician is simpler to sell and harder to game; if you're pricing managed services to end clients, per-device or per-user maps to how they buy. Either way, build the metering into the data model from day one. Retrofitting usage metering onto a system that wasn't designed for it is one of the most expensive refactors there is.
A focused tool (multi-tenant ticketing, your PSA/RMM integrations, and a billing engine for your contract model) typically launches in 16-20 weeks and runs $55K to $110K. A full platform with SLA engine, client portals, documentation sync, and reporting typically launches in 20-26 weeks and runs $130K to $300K. Migration from an existing PSA, complex integration semantics, and compliance requirements (HIPAA BAA, SOC 2 evidence collection) can extend both. We scope every project before pricing. Fixed cost, agreed before work starts.
Get a build-vs-buy plan for your IT team.
Tell us how your stack runs today: PSA, RMM, contracts, billing. We'll tell you what we'd build and how.
- Scope and cost agreed before work starts. No surprises. No obligation.
- Working prototype within 3 weeks of kickoff.
- Pay by milestone. You see progress before each invoice.
- 60-day post-launch warranty. Bug fixes, UI tweaks, and deployment support. No retainer.
- All conversations are NDA-protected.
