Four Systems, One Platform: Consolidating a Fragmented SaaS Stack in 8 Weeks

Most growing businesses don’t choose a messy software stack — they accumulate one. A CRM gets bought to chase leads. Accounting lands in QuickBooks. Project work spills into a second suite. And every gap in between gets filled with spreadsheets. Each tool made sense the day it was added. Together, they quietly tax the business every single month.

We recently took a residential and commercial design-and-build operation running Salesforce, Zoho, QuickBooks Online, and a stack of spreadsheets and folded all four into a single platform the company owns outright — in about eight weeks. The full outcome lives in the case study; this is how that kind of consolidation actually works, and why it’s worth doing.

The Real Cost of a Stack That Doesn’t Talk

Three costs, and most of them never show up cleanly on any single invoice:

• A fee for every employee who logs in. Most business software charges per seat. Run four tools, and a single new hire can mean four more seats to pay for — a tax that grows every time the team does.
• Double and triple entry. A new customer gets typed into the CRM, again into accounting, and again into a spreadsheet. Every keystroke is a chance for the three copies to drift apart.
• Siloed data. The one question that actually matters — “are we making money on this job?” — needs numbers from three systems that don’t share a definition of “customer,” let alone “project.”

Why Consolidation Usually Stalls

The blocker is rarely the software. It’s the fear: what if we lose data, or go dark for a week during the switch? So businesses keep paying the tax rather than risk the cutover.

We treat the move as an engineering job, not a copy-paste marathon. The data is extracted programmatically, reshaped to fit one model, checked, and loaded in bulk — so the cutover at the end is a controlled event, not a leap of faith.

The Migration, in Plain Terms

Four steps, regardless of how many systems you’re collapsing:

1. Pull everything out through each system’s API or export — Salesforce, Zoho, QuickBooks, and the spreadsheets alike.
2. Map every record to one shared model. A “customer” in Salesforce, a “contact” in Zoho, and a “payer” in QuickBooks are usually the same business. We reconcile them into a single record.
3. Dedupe and validate so the same company doesn’t land three times under three spellings.
4. Cut over once, cleanly, into a system the company owns.

Step 2 is where the real work hides. The same customer almost always exists in every system under a slightly different name, so we normalize first, then merge:

import pandas as pd

# One business often appears in all three systems under slightly different names.
# Normalize to a common key, then merge into a single source of truth.
def unify_customers(salesforce, zoho, quickbooks):
    sources = [
        ("salesforce", salesforce, {"Account Name": "customer_name", "Billing City": "city"}),
        ("zoho",       zoho,       {"Account_Name": "customer_name", "City": "city"}),
        ("quickbooks", quickbooks, {"DisplayName": "customer_name", "BillCity": "city"}),
    ]

    frames = []
    for source, df, mapping in sources:
        normalized = df.rename(columns=mapping)[["customer_name", "city"]].copy()
        normalized["source"] = source
        frames.append(normalized)

    merged = pd.concat(frames, ignore_index=True)
    # "ACME Pools, LLC" and "Acme Pools" collapse to the same match key.
    merged["match_key"] = (
        merged["customer_name"].str.lower().str.replace(r"[^a-z0-9]", "", regex=True)
    )

    # Keep one record per real business → loaded as a Frappe "Customer" DocType.
    return merged.drop_duplicates(subset="match_key", keep="first")

That is the whole game: one definition of a customer, one of a project, one of an invoice — instead of three of each that quietly disagree.

Eight Weeks, Not Ninety Days

Our typical small-to-mid timeline is about 90 days. This one landed in two months. What made it fast wasn’t cutting corners — it was the opposite:

• The team decided quickly. Approvals, access, and sign-offs didn’t stall between phases.
• We deployed standard first. Proven workflows went in as-is; anything bespoke was treated as a separate, later decision rather than a default.
• The data was reasonably clean. Spread across four systems, yes — but structured well enough to map without a long cleansing slog.

Own the platform first, customize second. That sequencing is what keeps a migration short.

What “Owned” Buys You

When the dust settled, more than 300,000 records lived in one place the company controls — its own private section of Google Cloud, billed like a utility rather than rented by the seat. The monthly software bill fell from roughly $2,500 to about $300, and an AI assistant that learns from the company’s own data now runs on top of it all.

AI shouldn’t be a fifth tool to log into. It should be how the one platform runs.

Principal Architect
Infinary Engineering Group