DEV Community: Themesic Interactive

Perfex CRM Google Sheets Sync: What Two-Way Actually Means

Themesic Interactive — Wed, 16 Sep 2026 00:01:00 +0000

Every CRM rollout runs into the same fact sooner or later: part of the team still lives in spreadsheets. The pipeline sits in the CRM, but the commission tracker, the quarterly budget, and the campaign report are Google Sheets, and someone keeps the two sides aligned by hand. That copy-paste step is exactly where numbers drift apart. This post looks at what a real Perfex CRM Google Sheets sync involves, why export-only integrations quietly fail, and where a two-way approach earns its keep in reporting and bulk-editing work.

Full disclosure before we go further: we build and sell the module discussed here, the Google Workspace Integration module for Perfex CRM. The first half of this article is general and stands on its own; the second half explains how our module approaches the problem, with every claim taken from its actual documentation.

Why teams still live in Sheets

It is tempting to treat spreadsheets as a legacy habit that a good CRM should eliminate. In practice, they survive because they are genuinely better at certain jobs. A spreadsheet is an ad hoc model, a report, and a mass editor in one surface. Formulas and pivot-style summaries take seconds to build. Everyone on the team already knows how to use one, including the finance person who will never log into the CRM. A CRM, by contrast, is structured and form-driven by design: great for a single record's lifecycle, slower for "change one value across forty rows while eyeballing the whole set."

The realistic goal is not to kill spreadsheets. It is to stop them from becoming stale forks of the truth.

Export-only is a snapshot, not a sync

Most "spreadsheet integrations" are really export buttons. You get a CSV or a generated sheet that is accurate for exactly one moment, then begins to age. Worse, the flow is one-directional: when a colleague fixes a phone number or updates a forecast figure in the exported sheet, that correction never travels back. Within a week you have two versions of the data and a reconciliation job at the end of the month.

Two-way sync means the relationship is live in both directions. Change the file on Google's side and the change is reflected in Perfex; change it inside Perfex and it updates in Google. Both platforms stay current, so there is one source of truth instead of a chain of diverging copies. That single property is what separates a sync from an export, and it is the bar any integration in this space should be measured against.

What Perfex CRM Google Sheets sync looks like when it is two-way

Our module brings that model directly into the Perfex admin area. You can create, edit, and manage Google Sheets without leaving the CRM, and edits flow both ways in real time: what you change in Perfex lands in Google, and what teammates change in Google shows up in Perfex.

The working loop is short:

Install the module. In Perfex CRM, open Settings, then Modules, then Upload, add the module's zip file, and activate it. The included documentation walks you through connecting the required Google account.
Create a spreadsheet from the dashboard. Give the new file a title and a description and the module creates it and links it for you. From that point the file is managed inside Perfex alongside your CRM data.
Work wherever it is convenient. Edit the sheet inside Perfex, or let a teammate edit it in Google. Either way both sides stay in step, and your whole library of synced files is managed from a single screen.
Choose the sync cadence. Fetch the latest data manually whenever you need it, or let Perfex CRM's own cron job refresh it automatically on a schedule. The sync settings can be tailored to your workflow.

One detail worth noting: this is not a Sheets-only tool anymore. The module started with spreadsheets in version 1.0, added Google Docs support in 1.2, and added Slides, Forms, and Drive files in 1.3. So a client proposal, a campaign deck, or an intake form can live under the same two-way sync as your spreadsheets.

Reporting and bulk-editing use cases

The documentation calls out four team patterns, and they map neatly onto the two jobs spreadsheets do best.

Reporting. Marketing teams organize campaign data, analyze metrics, and share reports; project managers keep project data in step so every stakeholder sees the latest information. Because the synced sheet is always current, the "report" stops being an artifact someone regenerates on Fridays. You share the synchronized file with team members once, and it stays accurate on both platforms without a re-export ritual.

Bulk editing. Sales teams track leads and manage sales data; finance teams keep financial records, budgets, and forecasts in sync. This is where the spreadsheet grid beats record-by-record form editing: sweeping changes across many rows is what Sheets was built for. Make those edits in the synced spreadsheet and they flow back rather than dying in a detached copy.

The common thread is eliminating double entry. Manual copying between systems is not just slow; it is the mechanism by which errors and discrepancies enter your data in the first place.

Permissions: the part people forget

Handing spreadsheet access to a whole company is how sensitive numbers leak. The module governs access per employee: administrators can grant or block specific staff members from reaching synced files through their admin area account. For private files there is an automated request-and-grant flow: a non-privileged staff member requests access, the file owner approves it, and sensitive documents stay in the right hands without an admin manually shuffling share settings.

When you should not use this

An honest fit check, because no module is right for everyone. If you need a one-time data dump for a migration, a plain CSV export is simpler; a sync layer pays off for living documents, not one-off transfers. If your organization is not on Google Workspace, this module does nothing for you, and it is built specifically for Perfex CRM, so it is useless on any other platform. Automated refresh rides Perfex CRM's own cron job, so your hands-off cadence is only as good as your cron setup; without reliable cron you are down to manual fetches. Finally, this is a synchronization and file-management tool, not a BI product: it keeps your sheets accurate, but building the analysis on top of them is still your job.

Key facts

Fact	Value
Current version	1.4.0 (updated 2026-05-29)
Compatibility	PHP 7.x and 8.x, MySQL 5.x and 8.x
Google apps covered	Sheets, Docs, Slides, Forms, Drive
Sync modes	Manual fetch or automatic via Perfex CRM's cron job
Access control	Per-employee grant/block plus request-and-grant for private files
Track record	266 sales on CodeCanyon, 4.43/5 from 7 verified CodeCanyon reviews
Licensing	One-time purchase, or a yearly Pro license

Links

If you are wrestling with a CRM-and-spreadsheets workflow, or wondering whether two-way sync fits your setup, ask away in the comments and we will answer.

Perfex CRM QuickBooks Integration: Ending Double Data Entry

Themesic Interactive — Mon, 14 Sep 2026 00:00:53 +0000

If your agency runs Perfex CRM for client work and QuickBooks for the books, there is a good chance someone on your team re-types invoices from one system into the other every single week. A Perfex CRM QuickBooks integration exists to remove exactly that job: invoices, payments, and expenses recorded in the CRM flow into the accounting ledger automatically, so both systems agree without anyone copying numbers by hand. This article covers what a sync like that should move, how it works mechanically, and the edge cases - taxes, regions, post-sync edits - worth planning for before you connect anything.

Full disclosure: we build and sell the module discussed here, the QuickBooks module for Perfex CRM. That said, the design questions below are the same whether you buy a module or script your own bridge, so most of this applies either way.

Why double data entry is a bookkeeping bug, not a chore

Manual re-entry between a CRM and an accounting package fails in three predictable ways. First, transcription errors: a transposed digit on one invoice out of forty is invisible until reconciliation, and then it costs an afternoon. Second, lag: the books are only as current as the last data-entry session, so mid-month reports from QuickBooks quietly disagree with what the CRM says clients owe. Third, and worst, partial payments: when a client settles an invoice across several payments, every installment is another chance for the two systems to drift apart.

None of these are effort problems. They are consistency problems, and consistency is exactly what software is for.

What the Perfex CRM QuickBooks integration syncs

The module moves three object types, in one direction: from Perfex into QuickBooks.

Invoices are pushed using Perfex's own core hooks at the moment they are created, so there is no waiting for a scheduled run.
Payments are mirrored when they are recorded against an invoice, and partial payments are tracked correctly - a customer paying in installments shows up accurately on both sides instead of forcing a manual correction later.
Expenses are synchronized on a schedule through the Perfex core cron job.

The one-way design is deliberate, and it is the part we would defend hardest even if we had not built this. A sync needs a single source of truth. Here, Perfex is where your team works - quotes, invoices, payment records, expense logs - and QuickBooks is the always-current ledger behind it. Two-way sync sounds more powerful on paper, but it introduces conflict resolution: if a record changes in both systems between sync runs, which version wins? For a small agency, "the CRM is authoritative, the ledger mirrors it" is the answer that keeps month-end close boring, which is the correct state for a month-end close.

The module also carries across custom fields and supports multiple taxes applied to the same item, so what lands in QuickBooks reflects what you actually logged in the CRM, taxes and totals intact.

A month in the life of an agency's books

Here is what the workflow looks like once the connection is live.

Your project manager raises a retainer invoice in Perfex on the 1st. The core hook fires and the invoice exists in QuickBooks before anyone thinks about it. The client pays half up front; that payment is recorded in Perfex and mirrored as a partial payment in QuickBooks. The balance arrives on the 25th and syncs the same way - no one reconstructs the payment history by hand.

Meanwhile, the team logs a software subscription and some contractor costs as expenses in Perfex. The next cron run carries them into QuickBooks automatically.

At close, your bookkeeper works entirely in QuickBooks and finds a ledger that already matches the CRM. The CRM-side team never opened QuickBooks; the accounting side never opened Perfex. That separation is the actual product here - the sync is just the mechanism.

Setup is short: install, activate, connect a QuickBooks account, and sync. No coding is required, and the included documentation walks through configuration with videocasts.

Edge cases to plan for: taxes, regions, and edits

This is the section to read before buying anything in this category, ours included.

Taxes. Multiple taxes on a single line item are supported, and tax handling covers real-world billing rather than only the simplest cases. Worth knowing from the changelog: version 1.0b specifically fixed VAT rate handling so duplicate entries no longer appear in QuickBooks - if you are evaluating older builds, that fix matters.

Regions. The module is built for companies based in the United States, Australia, the United Kingdom, Canada, South Africa, and India. France is explicitly not supported: the way French companies' taxes interact with the Perfex core puts French accounts intentionally out of scope. Support is defined by country rather than by a currency list, so if your setup falls outside those six markets, verify behavior against a test QuickBooks company before relying on it in production.

The cron dependency. Invoices and payments move via hooks, but expenses only sync when Perfex's core cron job runs. If your cron is flaky, your expense mirror is flaky. Confirm the cron is enabled and actually firing before you trust the numbers.

Edits after sync are manual. Once an invoice has been generated and synced, changes you make to it in Perfex must be applied in QuickBooks by hand - the same goes for payments and expenses. Practically, treat a synced record as committed: finalize invoices before issuing them, and make any later correction a deliberate two-system step.

When this module is the wrong choice

Honesty section. Skip this module if any of these describe you:

You need QuickBooks to push data into Perfex. This is a one-way sync by design. If your accounting team originates invoices in QuickBooks, this tool solves the wrong direction.
You are a French-based company. Unsupported, full stop.
Your workflow involves heavy editing of already-issued invoices. Every post-sync edit becomes a manual double-entry moment, which reintroduces exactly the problem you were trying to eliminate. Fix the workflow first, then automate it.
You cannot keep the Perfex cron running reliably. Expense sync depends on it.

If none of those apply, the trade-offs are favorable: requirements are just PHP 7.4 or higher and a current Perfex CRM install.

Key facts

Fact	Detail
Sync direction	One-way, Perfex to QuickBooks
Objects synced	Invoices, payments (incl. partial), expenses
Invoice trigger	Perfex core hooks, at creation
Expense trigger	Perfex core cron job, on schedule
Tax support	Multiple taxes per item; VAT duplicate fix in 1.0b
Custom fields	Carried across
Supported countries	US, AU, UK, CA, ZA, IN (France excluded)
Requirements	PHP 7.4+, current Perfex CRM, cron enabled
Current version	1.0b (updated 2026-05-04)

For track record: the module has 252 sales on CodeCanyon and holds 5.00/5 from 5 verified CodeCanyon reviews. On our own store it is available as a one-time purchase, with a yearly Pro license option.

Links

Running a different CRM-to-accounting setup, or hit an edge case we did not cover? Ask in the comments and we will answer.

Perfex CRM Zapier Integration: No-Code Automation With 4 Zap Recipes

Themesic Interactive — Sat, 12 Sep 2026 00:00:55 +0000

Perfex CRM is a solid system of record, but on its own it does not tell the rest of your stack what just happened inside it. A lead arrives, a payment is recorded, a support ticket is raised - and then a human re-types that information into a spreadsheet, an accounting tool, or a chat message. A Perfex CRM Zapier integration removes that manual relay. Our Zapier module registers Perfex as a native app on Zapier, so events inside the CRM can start workflows across the 7,000+ apps in the Zapier ecosystem, and other apps can write records back into Perfex, without anyone on your team writing integration code.

Full disclosure: we build and sell the module discussed here. This post is still education first: what the documented trigger and action surface actually covers, four Zap recipes you can rebuild in an afternoon, and a plain-spoken section on when this module is not the right tool.

How a Perfex CRM Zapier integration works

Zapier's core concept is the Zap: a simple "when this happens, do that" rule. Every Zap has a trigger (the event that starts it) and one or more actions (what happens next, in any connected app). The module's job is to make Perfex a first-class citizen on both sides of that equation. Installation takes a few seconds, not a migration weekend, and once the module is activated, Perfex behaves like a native app in the Zapier editor: you assemble automations by picking events and mapping fields, not by writing code.

This matters most for teams without a developer on call. Integrating Perfex with outside tools by hand means REST calls, authentication, payload mapping, and error handling. Zapier hides all of that behind a visual editor. If you can describe your workflow as a sentence ("when a lead is added in Perfex, post it to our sales channel"), you can probably build it.

The building blocks: 10 triggers and 11 actions

Everything below comes from the module's documented surface, so treat it as the real boundary of what you can automate without custom code.

Triggers - a new record in Perfex starts a Zap. The module fires when any of these is created in Perfex: Proposal, Invoice, Customer, Estimate, Payment, Contract, Ticket, Lead, Project, or Task. That is ten creation events covering the main objects of the CRM.

Actions - other apps write into Perfex. From any connected app you can create a Lead, Proposal, Invoice, Customer, Estimate, Contract, Ticket, Task, Project, or Timesheet. There is also one lookup action, Find Customer, which locates an existing customer record so an inbound flow can match against existing data instead of creating duplicates.

Direction is the thing to internalize when you plan automations: triggers move data out of Perfex, actions move data in, and Find Customer lets an inbound Zap check state before it writes.

Four Zap recipes grounded in that list

Each recipe below uses only documented triggers and actions on the Perfex side. The other side can be any of the 7,000+ apps Zapier connects.

Recipe 1: New lead, instant team visibility.

Trigger: New Lead in Perfex CRM.
Action: post a message in your team communication platform, with the lead's name and details mapped into the message body.
Optional extra action: add the same lead to your email marketing system so nurture starts immediately.

The value here is not sophistication. It is that nobody has to remember to check the CRM, because the CRM now announces itself where the team already lives.

Recipe 2: Payments into your books without retyping.

Trigger: New Payment recorded in Perfex.
Action: add a row to a spreadsheet that serves as your running cash log.
Optional extra action: push the same payment into your accounting software.

Month-end reconciliation is where manual entry errors surface. If every recorded payment lands in the log the moment it exists, the log and the CRM cannot drift apart.

Recipe 3: Any form, straight into the pipeline.

Trigger: a new submission in whatever form tool you already use (any form app available on Zapier).
Action: Create Lead in Perfex, with form fields mapped to lead fields.

This is the reverse direction: an outside app driving Perfex. It replaces the classic "export the form responses on Friday and import them into the CRM" ritual with a flow that runs in the background per submission.

Recipe 4: Inbound requests without duplicate customers.

Trigger: an inbound event in another app in your stack.
Step: Find Customer in Perfex, to check whether this person already exists.
Action: Create Ticket in Perfex, attached to the matched customer - or Create Customer first when the lookup comes back empty.

This one shows why the lone lookup action exists. Multi-step Zaps that check before they write are the difference between an automated CRM and an automated mess of duplicates.

Where this module is not the right answer

Three honest limits, so you can decide with open eyes.

First, the documented trigger list is creation events only - ten "new record" events. There is no documented trigger for updates, status changes, or deletions, so a workflow like "when an invoice changes status" has no direct event to hang off. Sometimes you can model around it (the New Payment trigger covers the moment money is actually recorded), but some status-driven workflows simply do not fit the documented surface.

Second, the action list is create operations plus one lookup. If your integration needs logic that Zapier cannot express, the module inherits an optional REST API with complete documentation of requests, responses, and parameters. That is the escape hatch for developers - with the caveat that custom code you build against it falls outside the scope of product support.

Third, the automation logic lives on Zapier's platform, which means a Zapier account and a dependency on a third-party service. If your policy rules out third-party automation platforms, the no-code path this module exists for is off the table, and custom development against the documented REST API is the route to evaluate instead.

None of that is hidden fine print. It defines who the product is for: teams that want the no-code path and are happy to let Zapier run the plumbing.

Key facts

Fact	Detail
Current version	2.0.5b (updated 2026-05-04)
Compatibility	PHP 7.x, PHP 8.x, MySQL 5.x, MySQL 8.x, CodeIgniter framework
Triggers	10, all "new record" events
Actions	11: ten create actions plus Find Customer
Ecosystem	7,000+ apps connectable through Zapier
Track record	176 sales on CodeCanyon, rated 5.00/5 from 5 verified CodeCanyon reviews
Setup	Installs and activates in seconds

Links

Got a workflow in mind and not sure it fits the trigger and action list? Describe it in the comments and we will help you map it out.

Perfex CRM vs RISE CRM: An Honest Comparison for Agencies

Themesic Interactive — Thu, 10 Sep 2026 00:00:44 +0000

If you run an agency and want a CRM you actually own - self-hosted, on your own server, with the data in a database you control - the shortlist almost always narrows to Perfex CRM vs RISE CRM. Both are PHP applications built on CodeIgniter, both cover the agency basics, and both get compared endlessly in forums, usually by someone with a stake in one side winning.

Full disclosure: we are Themesic Interactive, and we build and sell extension modules for both platforms, including the two REST API products used as evidence below. We get paid whichever CRM you choose, which is exactly why we can skip the winner-takes-all framing. There is no winner here. There is a better fit for how your agency works, and the goal of this post is to help you figure out which one that is.

Perfex CRM vs RISE CRM: two different philosophies

Perfex CRM is a client-work CRM. Its center of gravity is the commercial relationship: leads, proposals, estimates, invoices, subscriptions, contracts, support tickets. It also has the larger third-party module ecosystem of the two, so when Perfex does not do something out of the box, there is usually a module that adds it. That ecosystem matters more than it sounds, because Perfex does not ship a full REST API of its own - connectivity is one of the gaps modules fill.

RISE CRM leans team-and-project. It still handles clients, invoices and estimates, but it also covers internal operations: attendance, leave applications, teams, announcements, personal to-do lists. You can read this philosophy straight off the API surfaces of our two products: our RISE plugin exposes Attendance, Leave Applications, Teams, Announcements and ToDo endpoints because RISE itself ships those features, while our Perfex module's endpoint list has no equivalents. If you want one tool that faces clients and doubles as a lightweight team hub, that is RISE's pitch.

A workable mental model: Perfex keeps asking "what is happening with this client?" while RISE keeps asking "what is this team working on, and for whom?"

Where they overlap

The overlap is what puts them on the same shortlist at all. Both are self-hosted CodeIgniter applications running on modern PHP, and both cover clients, projects, tasks, invoices, estimates, tickets and a knowledge base. For an agency leaving spreadsheets or escaping per-seat SaaS pricing, either is a defensible choice on fundamentals. The real separation happens at the edges: module ecosystem, internal operations, and how each platform connects to the rest of your stack. That last part is where we spend our days, so let us get concrete.

The automation story on Perfex

Since Perfex has no full native REST API, automation runs through a module. Ours is the REST API module for Perfex CRM, currently at version 3.1.0, with 2,941 sales on CodeCanyon and rated 4.91/5 from 44 verified CodeCanyon reviews. What it gives you today:

A documented surface of 74 paths and 144 operations, described by an OpenAPI spec served at GET /api/openapi, importable into Postman or Insomnia.
Webhooks covering 124 events across 22 event groups, HMAC-signed and delivered asynchronously with retries, so external systems hear about CRM changes without polling.
A native MCP server at POST /api/mcp (JSON-RPC 2.0) exposing 148 tools to AI agents such as Claude, ChatGPT, Cursor and the n8n AI agent. The tool list is permission-filtered: an agent only sees what its API token is allowed to touch.
A batch endpoint (POST /api/batch) running up to 50 operations per request, plus native polling endpoints for Zapier, Make and n8n. Authentication is a token sent in the authtoken header, created from the API Management screen in the Perfex admin area.
For n8n specifically, a community node, @themesic/n8n-nodes-perfex-crm, covering 20+ resources with 130+ operations plus a polling trigger, so workflows do not need hand-rolled HTTP nodes.

The automation story on RISE

Our REST API plugin for RISE CRM, currently at version 2.1.0, plays the same role on the other platform:

322 documented endpoints across 54 groups, with copy-ready code examples in cURL, PHP, Python and JavaScript.
Machine-readable tooling: an OpenAPI 3.0 spec at /api/openapi.json, a Postman collection at /api/postman.json, Swagger UI at /api/swagger and an interactive playground at /api/playground.
An MCP server at /api/mcp (JSON-RPC 2.0) publishing over 200 permission-filtered tools across more than 40 resources. It is opt-in: disabled by default, enabled from the admin-only API settings screen.
Webhooks with HMAC-SHA256 signed delivery, per-webhook delivery logs and queued delivery with retries, plus polling triggers for n8n, Zapier and Make, and a batch endpoint for bulk work.
An n8n community node here as well, n8n-nodes-rise-crm on npm, plus a public code-examples repository at github.com/themesic/rise-rest-api-examples carrying the Postman collection and the OpenAPI specification.

One practical note: because RISE runs on CodeIgniter, some server configurations need /index.php/ inside API endpoint URLs. The documentation covers it, but budget ten minutes for that the first time you integrate.

Side by side:

	Perfex module (v3.1.0)	RISE plugin (v2.1.0)
Documented API surface	74 paths, 144 operations	322 endpoints, 54 groups
MCP for AI agents	148 permission-filtered tools	200+ tools, 40+ resources, off by default
Webhooks	124 events, 22 groups, HMAC-signed, async retries	Event catalog, HMAC-SHA256, queued with retries
Batch requests	Up to 50 operations per call	Supported
No-code platforms	Zapier, Make, n8n	n8n, Zapier, Make
n8n community node	20+ resources, 130+ operations, trigger	n8n-nodes-rise-crm

How to decide

Choose Perfex CRM when the commercial paper trail is your backbone - proposals, estimates, invoices, subscriptions, contracts - and you want the bigger catalog of ready-made modules behind you. Its automation layer also has the longer track record in its changelog: our Perfex module first shipped webhooks in version 2.1.1 and MCP in 3.0.1, and both have been refined through the current 3.1.0 release.

Choose RISE CRM when you want client work and internal operations in one place - attendance, leave, teams and announcements alongside projects and invoices - and a single API that reaches all of it. Be aware that the deep automation surface (MCP, webhooks, batch, reporting endpoints) all arrived with the plugin's 2.1.0 release in July 2026 - earlier releases focused on endpoint coverage - so plan a little extra testing time for those newer pieces.

And an honest word about when to buy neither API product: if your whole workflow lives inside the CRM's own interface and no external system needs the data, an API module is shelfware. Both products also assume you are comfortable with REST - our own documentation for each says plainly that if you are not, you should bring in a developer. Finally, no API layer changes a platform's philosophy: if RISE's project-first model fits your agency better, the size of Perfex's module catalog will not fix the mismatch, and vice versa.

Links

Running a specific stack and unsure which way to jump? Describe it in the comments and we will give you a straight answer.

Perfex CRM GraphQL API: Query Custom Module Data in One Request

Themesic Interactive — Tue, 08 Sep 2026 00:00:43 +0000

CRM data is relational to its core. A customer links to invoices, invoices link to payments, projects link to tasks and tickets, and the moment you install third-party modules, entirely new tables join that web. If you have ever tried to pull a complete picture of a single customer out of Perfex through a conventional API, you know the routine: one request per resource, then stitching the results together in your own code. That mismatch between deeply connected data and resource-per-endpoint design is exactly what a Perfex CRM GraphQL API is built to fix, and it is what this article digs into.

Full disclosure: we build and sell the module discussed here. It is the sibling of our REST API module for Perfex CRM, and we will be upfront about when the REST option is the better pick, because it genuinely is sometimes. The aim is that you leave with a clearer sense of how GraphQL maps onto CRM data, whether or not you ever buy anything from us.

Why CRM data fits GraphQL

REST APIs typically operate through predefined endpoints, each representing one resource. That structure is easy to reason about, but it gets awkward when the client needs data from several resources at once. You end up with one of two classic problems:

Over-fetching: an endpoint returns more data than the client needs, because the response shape is fixed on the server.
Under-fetching: no single endpoint returns enough, so the client makes multiple round trips and assembles the picture itself.

Fetching a customer's information along with their recent orders is the textbook case. Over REST, that usually means separate calls to a customers resource and an orders resource, then joining the results client-side. Over GraphQL, the client asks for exactly the fields it needs across both entities and receives them in a single response from a single endpoint. Fewer requests, less wasted transfer, and the joining logic lives in the query instead of your application code.

CRM data makes this difference bigger than usual, because almost nothing in a CRM stands alone. Reports, dashboards, and sync jobs nearly always want a slice that spans related entities. A strongly-typed schema also gives frontend and backend developers a shared, explicit picture of what data exists and how it connects, which shortens the conversation every time an integration changes.

What the Perfex CRM GraphQL API module does

The module adds a single unified GraphQL endpoint to a Perfex CRM installation. Through that one endpoint you can query every database table, field, and option in the install, so the integration is never boxed in by whatever subset the base CRM chooses to expose.

It is not read-only. The API supports the write operations an external system needs to keep itself and Perfex in step: adding a record, updating an existing record, and deleting a record. Queries can also be limited by record id, which keeps responses lean and predictable in production. That id-based limiting (id_in) arrived in version 1.0.1 alongside a round of security enhancements, so it is worth running the current release.

To shorten the ramp-up, the module ships with example queries organized per programming language and per method, and there is complete online documentation for building your own connections. Installation itself takes a few seconds: install, activate, and the endpoint is working. Compatibility covers PHP 7.x and PHP 8.x on CodeIgniter, the stack Perfex CRM runs on.

For provenance: the module has 67 sales on CodeCanyon and holds a 4.80/5 from 5 verified CodeCanyon reviews.

Custom module tables are where it earns its keep

Here is the part that matters most for real-world Perfex installs. Very few production deployments run a vanilla CRM. The Perfex ecosystem is full of third-party modules from different authors, and many of them create their own tables and fields. Those tables hold data your business depends on, but they are invisible to any API that only covers the core schema.

This module treats non-native tables as first-class citizens. You can query every table, field, and option created by third-party modules through the same GraphQL interface you use for native Perfex data. If a module you installed adds unique fields or drives a custom workflow, that information is reachable the same way client records are.

The practical consequence is that cross-entity reporting stops being a special project. A query can span native entities and custom module data in one request, which is exactly what analytics dashboards, data sync jobs, and operational tooling want. And because the architecture is designed to stay compatible with existing modules, the API keeps pace as your install grows instead of freezing your integration at whatever the core CRM exposed on day one.

One note on examples: we are deliberately not pasting query syntax into this article. Working requests live in the module's per-language examples and its online documentation, and copying real, current examples from there beats adapting snippets from a blog post that may age.

When REST is the better pick

An honest comparison cuts both ways, so here it is.

If your integration touches a single resource in a fixed, predictable shape - push a new lead in, pull a list of invoices out on a schedule - REST is simpler and entirely sufficient. There is no join problem to solve, so GraphQL's main advantage never comes into play. The same goes for teams already fluent in REST conventions, with client code, logging, and habits built around them: the switching cost is real, and a working REST integration is worth more than a theoretically cleaner one.

GraphQL wins when the questions you ask the CRM span related entities, when response size matters because clients are bandwidth-constrained or response times are critical, or when the data you need lives partly in custom module tables that a fixed set of endpoints was never designed to expose.

We sell both. The REST API module for Perfex CRM is the companion product, and picking it over the GraphQL module is sometimes the right call. We would rather you choose the fit than the newer acronym.

Honest limits

A few things this module will not do for you. It does not remove the GraphQL learning curve: if your team has never written a GraphQL query, budget time for that, and if you are not familiar with APIs at all, it is genuinely worth hiring an expert to build the connection rather than fighting through it alone. Full-database reach is also a responsibility as much as a feature: an API that can read and write every table deserves careful thought about who holds the credentials and what your integration actually needs to touch. And the module is young - version 1.0.1, updated 2026-05-04, with a review base that is still small - which is worth weighing if you only adopt tools with a long public track record.

Key facts

Fact	Detail
Current version	1.0.1
Last updated	2026-05-04
Compatibility	PHP 7.x, PHP 8.x, CodeIgniter
Operations	Query, add, update, delete records
Scope	All tables and fields, including third-party module tables
Query control	Limit results by record id (id_in)
Track record	67 sales on CodeCanyon, 4.80/5 from 5 verified reviews

Links

Building an integration and unsure which of the two APIs fits your case? Describe it in the comments and we will give you a straight answer.

Leaving GoHighLevel: A Migration Checklist That Works

Themesic Interactive — Mon, 07 Sep 2026 08:30:59 +0000

Nobody loses their data by cancelling GoHighLevel. They lose it in the weeks before - by cancelling first and exporting second, by forgetting that the SMS number was provisioned through the platform, by tearing down a form that was still quietly feeding leads. Leaving GoHighLevel is not a decision, it is a sequence, and getting the sequence wrong costs more than the subscription ever did. This checklist is written for someone who has already decided to move off GoHighLevel and wants the exit to be boring.

One disclosure before the first step: we build and sell LeadHub, a self-hosted CRM that is one of the places you might be migrating to, so we have a position here - weigh the article accordingly. The order of operations below holds regardless of your destination.

Step 1: Export everything while the account is still active

The single most important rule of any platform migration: export while you can still log in. Every task on this list is recoverable except this one.

GoHighLevel lets you export contacts to CSV, and opportunities can typically be exported per pipeline as well - the exact menus move around between releases, so follow the current documentation rather than a screenshot from a blog post. What you want out, in order of value:

Contacts, with every custom field and tag included. Check the export options rather than accepting defaults - a contacts file without your custom fields is half a database.
Opportunities, per pipeline, so you keep stage, value and owner alongside the contact.
Notes and conversation history, to whatever extent the current export tooling covers them. Anything the exporter cannot give you as data, capture manually for your highest-value accounts.
Email templates and copy. Copy the actual text and HTML out now; rebuilding copy from memory is where migrations silently lose conversion.
Screenshots or screen recordings of every workflow, funnel and calendar configuration. Not because you can import a screenshot, but because you will rebuild from it.

Be clear-eyed about what an export is. This is not a GoHighLevel criticism, it is how hosted platforms work structurally: exports give you the data - rows of contacts and deals - not the machine. Funnels, workflows and automation logic do not travel as files you can replay somewhere else. The rows come with you; the machinery gets rebuilt.

Verify the exports the same day. Open the CSVs, count the rows against what the dashboard shows, and spot-check ten records for custom fields. A corrupt or truncated export discovered after cancellation is not a bug report, it is a loss.

Step 2: Inventory what you actually use

Most GoHighLevel accounts are archaeological sites - three years of funnels, test workflows and abandoned calendars stacked on top of the five things that actually run the business. Migrating all of it is how a two-week move becomes a three-month stall.

Make three lists:

Capture points with real traffic: forms, funnels, chat widgets and calendars that produced a lead in the last 90 days.
Automations that actually fired last month: not the ones that exist, the ones with recent execution history.
Everything else: archive it in your export folder and do not rebuild it.

The honest output of this exercise for most agencies is short - a handful of forms, one or two booking calendars, a pipeline per service line, and a follow-up sequence or three. That short list is your migration scope. Everything not on it is nostalgia.

Step 3: Port or replace phone numbers before you cancel

Phone numbers are the easiest thing to lose in a GoHighLevel migration and the hardest to get back. Numbers used inside the platform are typically provisioned through its phone system, which means they live with the platform, not with you. Two options, both of which must complete before cancellation:

Port the number out to your own Twilio or Plivo account. Porting is a carrier-level process that commonly takes days to weeks depending on the number and country - start it first, because an account closed mid-port is the classic way a number dies.
Replace the number and update every place it is published - Google Business Profile, ad extensions, email signatures, printed material. Cheaper and faster, at the cost of continuity.

Going bring-your-own also moves the compliance paperwork to you: A2P registration for business SMS in the US, and whatever sender registration your country requires, now lands on your provider account instead of the platform's. Budget real calendar time for it.

On the destination side, LeadHub connects to your own Twilio or Plivo account, chosen per workspace - click-to-call and SMS run at your provider's direct rates, every call is logged with status and duration, and Twilio calls add recording with AI transcription and summary. Plivo is worth pricing if you operate in India or several other regions where its rates run much lower. Send a test SMS and place a test call from the new system while the old account still works, so there is never a moment when no number answers.

Step 4: Rebuild capture first - leads stop for nobody

Here is the order-of-operations mistake that defines a failed GoHighLevel migration: moving the database before moving the front door. Your contacts can wait a week in a CSV. A lead that hits a dead form tonight is gone.

So the rebuild order is capture first, data second:

Stand up the new system. LeadHub installs from a browser-driven installer - upload, visit the URL, follow the steps, no SSH and no Composer - and runs on ordinary shared or VPS hosting.
Rebuild forms and widgets. LeadHub's forms support multi-step logic, file uploads and reCAPTCHA, and the embeddable widget drops a branded capture form onto any site from a single script tag.
Rebuild the landing pages that actually convert using the drag-and-drop builder's blocks - hero, features, pricing, FAQ, testimonials, CTA forms - with editable meta tags and schema for SEO.
Reconnect ad and channel integrations. LeadHub captures from 19 channels natively - Facebook Lead Ads, Instagram, TikTok, LinkedIn, Google Ads, WhatsApp, Calendly, Typeform, IMAP email parsing and more - so the sources you inventoried in Step 2 repoint without Zapier glue.
Rebuild booking. The customer-facing calendar does two-way Google Calendar and Microsoft Outlook sync with conflict detection, buffer time, availability rules and round-robin, auto-creates a lead from every booking, and sends confirmations with 24-hour and 1-hour reminders out of the box.
Then import the data. LeadHub's CSV import maps your exported columns to your own custom fields, which is where the Step 1 export pays off, and duplicate detection with fuzzy email/phone matching plus a merge workflow cleans up the overlap from your dual-running window.

Run both systems in parallel for at least one full billing cycle. Leads captured twice are a nuisance; leads captured zero times are revenue.

What moves when leaving GoHighLevel - and what gets rebuilt

GoHighLevel surface	Self-hosted equivalent in LeadHub	How it moves
Contacts + custom fields	CSV import mapped to custom fields	Ports as data
Pipelines and opportunities	Kanban pipelines with custom stages, deal values, probabilities	Rebuild stages, import deals
Forms and surveys	Multi-step forms, embed widget, reCAPTCHA	Rebuild
Funnels and pages	Drag-and-drop landing-page builder	Rebuild the winners only
Calendars	Booking calendar with Google/Outlook sync and reminders	Reconnect and re-link
Email campaigns	Sequences with delays, conditions, stop-on-reply, stop-on-won	Rebuild from exported copy
Workflows	Trigger-condition-action flows, sequences, AI SDR	Partially - see below
Phone and SMS	Your own Twilio or Plivo account	Port or replace numbers

The honest gap: workflows do not port one-to-one

This is the part of leaving GoHighLevel that deserves a plain statement rather than a sales paragraph. GoHighLevel's workflow builder is genuinely deep - wait and delay steps, if/else branching, A/B split testing and per-step analytics are real capabilities, and they are ahead of what our flow builder does today. LeadHub's Visual Flow Builder wires triggers to conditions and actions on a drag-and-drop canvas; it does not have wait steps, branching or split tests inside a flow.

What carries the follow-up load instead is the sequences engine: email sequences with delays between steps, conditions, stop-on-reply and stop-on-won behaviour, and open, click and reply tracking. Audit your GHL workflows against that and a useful pattern emerges - most of what agencies build as workflows are linear nurture sequences wearing workflow clothes, and those translate directly. Appointment reminder chains do not need rebuilding at all, because booking confirmations with 24-hour and 1-hour reminders ship built in. Assignment and notification workflows become trigger-condition-action automations - round-robin assignment, lead scoring, SMS, webhooks and Slack notifications - with WhatsApp template automations alongside. And the "follow up until they answer" job goes to the AI SDR agent, which emails every new lead until a human replies.

The genuinely branchy workflows - the ones that wait three days, check a condition, split the path and measure each branch - are your real migration cost. Count them honestly. If your delivery model depends on many of them, that is a legitimate reason to stay on GoHighLevel, and no checklist should talk you out of it.

Cancel last, and only against this list

Cancelling is the final step, never a milestone along the way. Time it against your billing renewal, and confirm the current cancellation procedure in GoHighLevel's own documentation, since terms and notice requirements can change. Cancel only when every box below is ticked:

Contacts and opportunities exported, opened, row-counted and spot-checked
Email copy, templates and workflow screenshots archived
Phone numbers ported to your own Twilio or Plivo account - test call and test SMS completed - or replaced everywhere they are published
Every active capture point rebuilt and re-pointed, with a test lead submitted through each one and visible in the new pipeline
CSV import completed, custom fields mapped, duplicates merged
Follow-up sequences live, with stop-on-reply confirmed against a test reply
Booking calendar synced to Google or Outlook and taking real bookings
One full parallel billing cycle completed with no leads lost

The day you cancel should be the least dramatic day of the whole migration. If it is not, the sequence was wrong - and the sequence is the product of this checklist, not the destination.

LeadHub vs GoHighLevel: An Honest Comparison for Agencies

Themesic Interactive — Sun, 06 Sep 2026 00:01:00 +0000

Every agency CRM comparison is written by someone, and that someone usually sells something. Here is ours, in the second sentence where it belongs: we build and sell LeadHub, a self-hosted multi-tenant SaaS CRM, which makes this LeadHub vs GoHighLevel comparison a vendor's document - put that weight on the scale before you read on. What we can offer instead of neutrality is a comparison built to survive readers who have actually used GoHighLevel: GHL's advantages named specifically, LeadHub's gaps stated before its strengths, and a closing decision rule that deliberately sends some agencies back to their GHL dashboard.

The comparison is odd from the start, because the two products are not the same kind of thing. GoHighLevel is a hosted platform you subscribe to - tiers commonly cited at roughly $97, $297 and $497 a month as of mid-2026, with email, SMS and call usage rebilled through the platform on top; always confirm against their current pricing page. LeadHub is software you buy once and run on your own server: complete unencrypted Laravel source, your database, your hosting bill. Most of the rows below are downstream of that one categorical split, which is why this is really a GoHighLevel vs self-hosted CRM decision wearing two product names.

Where GoHighLevel wins, said first

If you have run serious campaigns inside GHL, you already know where its center of gravity sits, and an article that danced around it would deserve to be closed.

Workflow automation depth. GoHighLevel's workflow engine supports wait and delay steps inside a flow, if/else branching, A/B split testing between paths, and per-step analytics that show where contacts stall. LeadHub's Visual Flow Builder is a drag-and-drop node canvas that wires triggers to conditions and actions - and that sentence is the complete, honest feature description. It has no wait steps inside a flow, no branching, no split tests and no per-node statistics. If your delivery genuinely depends on that engine - timed, multi-branch nurture with split-tested paths across many sub-accounts - GoHighLevel is the better product for you today, full stop.

The ecosystem. Years of courses, templates, communities and hires who already know the interface have accumulated around GHL. That gravity is real, it is worth money in onboarding time alone, and any competitor - hosted or self-hosted - asks you to walk away from it.

Someone else runs the servers. Uptime, scaling and infrastructure patching are GoHighLevel's problem, priced into the subscription. Self-host and they become yours. We will price that honestly below rather than pretend it is free.

LeadHub vs GoHighLevel at a glance

One table, because the structural differences genuinely fit in one:

	GoHighLevel	LeadHub
What it is	Hosted subscription platform	Self-hosted software you own
The code	Theirs; you rent access	Complete unencrypted Laravel source, free future updates
Your data	On their platform	In your MySQL database, on your server
Cost structure	Subscription (roughly $97 to $497 a month, mid-2026, check their page) plus usage rebilling	One-time license plus hosting; sending at provider rates
Workflow automation	Waits, if/else branches, A/B splits, per-step analytics	Trigger-condition-action flows; sequences and the AI SDR carry follow-up
Lead capture	Native plus its integration ecosystem	19 native channels plus REST API and HMAC-signed webhooks
White-label resale	SaaS mode on the top tier	Multi-tenant core: your plans, your prices, five payment gateways
Uptime, updates, backups	Theirs	Yours

Ownership and economics: the structural wins

Everything on LeadHub's side of that table traces back to one fact: you own it.

The code is yours. LeadHub ships as complete unencrypted Laravel source - no obfuscation, no IonCube - with free future updates. Nobody can move a feature you depend on to a higher tier, change the terms under you, or sunset the product out of your stack. On a rented platform every one of those remains possible, however unlikely, because that is what renting is.

The data is where you put it. Every lead, conversation, pipeline stage and receipt sits in a MySQL database on a server in the country you chose. Export is not a plan feature a vendor grants; it is your own database.

The bill stops compounding. A subscription plus usage rebilling grows precisely when your marketing works. A purchase plus hosting stays flat, and communications run at direct provider rates: click-to-call and SMS go through your own Twilio or Plivo account, chosen per workspace - with Plivo notably cheaper in India and many regions - while email leaves through your own SMTP. Twilio calls add recording with AI transcription and summary on top.

Capture is native, not glued. LeadHub ingests leads from nineteen channels without middleware: Facebook Lead Ads, Instagram, TikTok, LinkedIn, X, Snapchat and Pinterest; WhatsApp, Viber and Telegram; Google Ads, YouTube and Microsoft Ads; IMAP email parsing, Typeform, JotForm, Calendly and web forms; plus an embeddable widget that drops a branded form onto any site from one script tag. Source, campaign and UTM tags arrive attached to each lead, so attribution exists without a mapping step.

The white-label question: whose customers are they?

This is where an agency CRM comparison stops being about features and starts being about what business you are in.

GoHighLevel's answer to resale is SaaS mode on its top tier - commonly cited around $497 a month as of mid-2026, hedged as ever. Your brand goes on the front, but the platform underneath remains theirs: their feature set, their terms, and your margin stacked on top of their subscription plus usage rebilling. That is not a criticism - it is simply what reselling a rented platform means.

LeadHub is multi-tenant from the ground up, so as a self-hosted GoHighLevel competitor it answers the same question differently: you become the vendor. Every tenant - your customer - gets a white-labeled workspace with its own logo, favicon, primary and accent colors, app name and footer text, backed by query-level data isolation so tenants never see each other's leads. You build the plans: per-plan feature gates, usage limits and seat caps, with feature flags that can hide entire admin sections per tier - Reports, Brand and Domain, Communications, Advanced, Tools and Templates. You collect through five gateways - Stripe, PayPal, Razorpay, Paystack or manual bank transfer - with tax-compliant, sequentially numbered receipts, coupons, and an affiliate engine paying 20% recurring commissions. The super-admin panel shows MRR, ARR and churn, and one-click tenant impersonation (60-minute audited sessions) lets you support customers without ever asking for a password. The subscription your customer pays is your revenue, not your markup on someone else's.

The automation gap, measured honestly

Conceding the workflow engine would sink this comparison if follow-up were impossible without it. It is not, because the follow-up jobs that actually move agency revenue run on different machinery:

Email sequences run with delays, conditions, stop-on-reply and stop-on-won behavior, plus open, click and reply tracking. Follow up until the lead answers or the deal closes, then stand down automatically - the deterministic workhorse.
The AI SDR agent autonomously follows up every new lead by email until a human replies, so nothing dies of silence in the pipeline. It runs on your own LLM API key, is optional and plan-gated, and the CRM works fully without any AI keys.
Booking automation sends confirmations with .ics attachments plus 24-hour and 1-hour reminders - the no-show prevention most agencies actually mean by "reminder workflows".
Marketing automations follow the trigger, condition and action model: round-robin lead assignment, lead scoring, SMS, outbound webhooks and Slack notifications.
WhatsApp template automations send approved templates to reach a brand-new lead outside the 24-hour messaging window, with template variables mapped to lead fields.

What does not carry over: a forty-step branching GHL workflow will not port one-to-one into trigger-condition-action flows, and pretending otherwise would waste your migration week. Before deciding how much that matters, open your GHL workflow list and count which branching workflows actually fired last month. That number decides more than any comparison table - and it is your number, so count it.

What LeadHub asks of you in return

The subscription you stop paying converts partly into responsibility, and a fair comparison prices that in:

Hosting is yours. LeadHub needs PHP 8.4 or higher and MySQL, installs through a browser-driven installer with no SSH, no command line and no Composer, and covers shared-hosting realities like URL-based cron and a sync mail driver. Ordinary PHP hosting works; choosing and paying for it is on you.
Updates are yours. They run from the browser, executing migrations and clearing caches without SSH - but you schedule the click.
Backups are yours. Verifiable, downloadable database backups are built in; storing them off-server and testing a restore is your job.
Security splits. The application ships TOTP two-factor authentication, brute-force lockout, a super-admin IP allowlist and a full audit trail; the OS and PHP patching underneath belong to you or your host.
Support is yours if you resell. Ownership makes you the vendor, and vendors answer tickets.

The decision rule, by agency type

No single verdict survives contact with real agencies, so here are three that do:

The automation-first agency. Your delivery is built on multi-branch workflows, timed waits and split-tested follow-up across many sub-accounts, and you use that engine daily. Stay on GoHighLevel - the subscription is buying capability LeadHub does not have today, and we would rather tell you that than refund you later.
The capture-and-close agency. Your real usage is lead capture, a Kanban pipeline, follow-up sequences and a booking calendar - which describes most agencies under ten people. Ownership covers everything you touch for one purchase plus hosting, and the compounding subscription was renting an engine you never drove.
The agency that wants to become a platform. You intend to sell a CRM under your own brand. SaaS mode makes you a reseller on someone else's platform; LeadHub makes you the vendor - your plans, your prices, your gateways, your customers - with the support burden that word honestly carries.

The next step costs one hour: export your GHL workflow list, mark each entry as sequence-shaped (delays and follow-up until reply) or branch-shaped (waits, if/else, splits), and note which fired last month. If the fired column is mostly sequence-shaped, the comparison above just became a migration plan.

Self-Hosted AI Customer Service Without the SaaS Inbox

Themesic Interactive — Sun, 06 Sep 2026 00:00:45 +0000

Most AI customer service tools follow the same pattern: sign up for a SaaS inbox, pipe your WhatsApp, email, and chat traffic through their cloud, and let their models read everything. That works until you ask where your data actually lives. Every message, phone number, and complaint history now sits in a third-party database under someone else's retention policy. If you already run Perfex CRM on your own server, there is another way: self-hosted AI customer service, where the inbox, the customer records, and the full conversation history stay on infrastructure you control.

That is the design goal behind PulseChat, a module for Perfex CRM. Full disclosure: we build and sell it. This post is less a pitch and more a walkthrough of what a self-hosted setup looks like in practice, where AI fits into it, and where the self-hosted boundary honestly ends.

What self-hosted AI customer service means here

Perfex CRM is a self-hosted PHP application built on CodeIgniter, and PulseChat's compatibility list covers PHP 7.x and 8.x with MySQL 5.x and 8.x. PulseChat installs into Perfex as a regular module, which means the operational core of your support stack lives in your own database:

Conversations from every channel land in a dedicated Channels tab inside Perfex.
Each external sender is matched to an existing client, contact, or lead whenever possible, so agents see the name, company, open tickets, invoices, and past interactions next to the thread.
Channel credentials and tokens are stored encrypted in your installation.
Access follows Perfex's own permission model, with granular capabilities for who can use AI, manage channels, or view analytics.
Recurring work like email polling runs through Perfex cron, the background-job mechanism your installation already uses.

The channels: WhatsApp (team replies from a verified business number), Telegram (through your bot), email (real-time conversations over IMAP and SMTP), SMS, plus Slack and Viber bridges. The point is not any single channel; it is that all of them terminate in your CRM instead of a rented inbox.

Contrast that with the SaaS model, where the conversation store, identity matching, and analytics live in a vendor's cloud and your CRM gets, at best, a sync. Here the CRM is the system of record because the conversations are physically in it.

Where the AI actually sits

PulseChat's AI layer connects to OpenAI (ChatGPT) and Anthropic (Claude), with configurable models such as gpt-4o, gpt-4o-mini, and Claude 3.5. You pick the provider and model, set temperature and max-token limits, and customize the system prompt so drafts match your brand's tone.

The features are assistive rather than autonomous:

Draft Reply generates a complete response from the recent messages in a thread, for an agent to review and send.
Smart Suggestions offers three short ready-to-send replies as clickable chips.
Rewrite adjusts a draft to be more professional, friendly, or concise.
Spelling and Grammar cleans up a message before it goes out.
Summary condenses a long back-and-forth into bullet points for handovers.
Sentiment Analysis flags angry or at-risk customers so they get priority.
Translation lets an agent read and reply in the customer's own language.

Two details matter for the data-ownership argument. First, every AI call is logged per conversation with model, tokens, cost, and duration, so you can see exactly which provider was called, how often, and what it cost. Second, AI is a switch, not a foundation: you can turn the AI features off entirely in settings and PulseChat still works as a plain omnichannel inbox.

Automation rules that run on your own box

An automation rules engine evaluates every incoming message inside your installation. Typical rules look like this:

Route a WhatsApp message that hits your sales number to the sales team and tag it as a lead.
Open a ticket and set status to pending when an email subject contains "support".
Set priority to urgent and notify the account manager when the customer is marked VIP.
Route a Spanish-language message to the Spanish-speaking team with a translated AI draft ready to go.

Rules can route conversations to a staff member or team, set status and priority on arrival, tag threads for reporting, trigger AI auto-replies for common low-risk questions, and create tickets straight from a conversation. Because the rules run in the CRM, the objects they create (tickets, assignments, tags) are native Perfex records, not webhook copies of them.

What a first week looks like

Setup is install, activate, and connect channels by following the included documentation; there is no coding step. From there, three scenarios drawn from how teams actually use it:

Lead capture on WhatsApp. A prospect messages your sales number. PulseChat creates or matches an external contact against a Perfex lead, an automation rule assigns the conversation to sales, the AI proposes a welcome message with a few qualifying questions, and the whole thread lands under the lead profile.

Multi-language support over email and Telegram. Customers write in different languages across both channels. Everything centralizes into unified conversations, agents reply through AI translation in English, Spanish, or French, and Summary lets an agent joining mid-thread catch up from bullet points instead of scrolling.

Internal plus external collaboration. A support agent hits a hard technical question. The external thread stays in the Channels tab, the agent opens a staff group chat (PulseChat also covers staff-to-staff direct messages, staff-to-client messaging through the client portal, and group conversations), the team agrees on an answer, AI rewrites it in plain language, and the reply goes back out on the channel the customer used.

The changelog shows steady maintenance rather than a frozen codebase: the current release is 1.3.5 (June 2026), PHP 8.5 support landed in 1.2.7, and recent versions focused on webhook and logging improvements.

Where the self-hosted line honestly ends

Self-hosted does not mean air-gapped, and it would be dishonest to imply otherwise. When an agent clicks Draft Reply or runs a translation, the relevant thread content is sent from your server to the AI provider you configured, OpenAI or Anthropic. Those are the two documented providers; a local LLM option is not part of the feature set. If your compliance posture requires that no conversation text ever leaves your network, run PulseChat with AI disabled (a supported configuration) or handle the AI part elsewhere.

A few more cases where this is the wrong tool. If you do not run Perfex CRM, the module is useless to you; it is not a standalone product. If your main support volume lives on a channel outside the supported list, verify that before buying instead of assuming a bridge exists. And self-hosting means the operations are yours: server, database backups, cron jobs, and channel credentials all sit on your side of the line. That is the price of data ownership, not a hidden defect, but it is real work a SaaS vendor would otherwise absorb.

Key facts

Fact	Value
Current version	1.3.5, updated 2026-06-24
Platform	Perfex CRM module (PHP 7.x/8.x, MySQL 5.x/8.x, CodeIgniter)
Channels	WhatsApp, Telegram, email (IMAP/SMTP), SMS, Slack, Viber
AI providers	OpenAI (gpt-4o, gpt-4o-mini) and Anthropic (Claude 3.5), configurable
AI controls	Temperature, max tokens, custom system prompt, per-conversation usage logs
Track record	43 sales on CodeCanyon
Licensing	One-time Standard purchase or yearly Pro license

Links

If you are weighing a SaaS helpdesk against self-hosting on your own Perfex install, or you want details on how any of this works under the hood, ask in the comments and we will answer.

Is GoHighLevel Worth It for a Small Agency? A Fair Test

Themesic Interactive — Sat, 05 Sep 2026 03:18:31 +0000

Somewhere around the third month, most small agencies discover which GoHighLevel features they actually open: the pipeline board, a couple of forms, one follow-up sequence and the booking calendar. Before we go further, disclosure: we build and sell LeadHub, a self-hosted CRM that competes with GoHighLevel, so read everything here knowing we have a horse in this race. That conflict is exactly why this article is built as a test you run on your own account, not a verdict we hand down.

So - is GoHighLevel worth it for a small agency? Sometimes genuinely yes, and we will say so plainly below. Sometimes you are paying roughly $297 a month, forever, for the nine tenths of a platform you never touch. The only way to know which agency you are is to audit what you actually use, price it, and compare that against owning the same subset outright. The audit takes about an hour. Here is how to run it.

What GoHighLevel Does That Almost Nothing Else Does

A fair test starts by conceding the other side's strengths, and GoHighLevel has real ones.

Its workflow automation engine is the deepest in this segment. Workflows can pause with wait and delay steps, branch with if/else conditions, A/B split contacts down different paths, and report per-step analytics so you can see exactly where a 14-step nurture leaks. If your agency's service delivery is built on that kind of logic - long conditional reactivation campaigns, reminder chains that behave differently depending on the response, split-tested follow-up running across dozens of sub-accounts - GoHighLevel earns its fee, and no trigger-condition-action flow builder replaces it today. Including ours.

Consolidation is real too: funnels, calendars, pipelines, email and SMS under one login instead of five separate subscriptions, plus a large ecosystem of snapshots, templates and courses that has grown up around the platform. And because it is a managed platform, uptime, patching and infrastructure are somebody else's job.

The structural facts sit on the other side of the ledger: you cannot self-host it, you do not own the code, your data lives on their platform, and the price is a subscription plus usage rebilling for email, SMS and calls. Neither list cancels the other. The question is which list your agency actually lives on.

When GoHighLevel Is Overkill

Now the honest question in the other direction: what does your team do in the CRM on a normal Tuesday?

For most agencies under ten people, the real workload is four jobs:

Capture - leads arrive from Facebook Lead Ads, Google Ads, a website form.
Pipeline - someone drags cards across stages and logs calls.
Follow-up - a sequence of emails goes out until the lead replies.
Bookings - prospects pick a slot, and reminders cut the no-shows.

None of those four needs wait steps, branching or split testing. They need reliable capture, a Kanban board, a sequence engine with a stop condition and a calendar that syncs. If that describes your last month, then "do I need GoHighLevel" has a specific answer: you need about a tenth of it - and at the commonly cited tiers of roughly $97, $297 and $497 a month as of mid-2026 (always verify against their current pricing page), the other nine tenths is not free. It compounds every month you stay.

Overkill is not a criticism of the product. It is a mismatch between a deep platform and a shallow requirement - and the subscription is priced for the platform, not for your requirement.

The One-Page Audit: What Did You Touch Last Month?

Run this before your next renewal. One page, four steps, about an hour.

List what you used. Walk GoHighLevel's left navigation and write down every feature anyone on the team opened in the last 30 days. Not features you plan to use - features with fingerprints on them.
Sort into three buckets. Core (the business stops without it), Convenient (nice, but replaceable), Untouched (it exists; nobody has opened it).
Price the bill against the Core bucket. Take last month's full invoice - subscription plus the usage wallet for email, SMS and calls - and divide it by the number of Core items. That is your real per-feature cost.
Flag the automation question. For each Core automation, note whether it uses waits, if/else branches or A/B splits. This one column decides more than everything else on the page.

Two outcomes are common. Agencies that genuinely run on the workflow engine find a Core bucket full of branching automations - the audit tells them to stay, and they should. Agencies doing the four jobs find a Core bucket of pipeline, forms, one sequence and a calendar, an Untouched bucket longer than the other two combined, and a per-feature cost that is uncomfortable to read out loud.

Is GoHighLevel Worth It? Run the Three-Year Numbers

Software decisions feel monthly; costs are cumulative. At the commonly cited middle tier of roughly $297 a month, three years comes to about $10,692 before usage - and email, SMS and phone usage are rebilled on top through the platform wallet, month after month. At roughly $97, the floor is still about $3,492 over three years, plus usage. Those figures move whenever the vendor's pricing does, so check the current page before quoting them - but the structure does not move: a subscription scales with time and usage, and it never converts into an asset you own.

To be fair in both directions: if you resell GoHighLevel under its SaaS mode and your clients' subscriptions cover the fee with margin, the subscription is a cost of goods sold and the arithmetic can work out fine. The three-year number stings specifically when the platform is a cost center - a tool your small agency uses internally at a tenth of its depth.

What Owning the Core Four Actually Looks Like

This is where our product enters, with the caveat repeated: LeadHub is ours. It is a self-hosted, multi-tenant SaaS CRM - a one-time purchase you install on your own server, delivered as complete unencrypted Laravel source code with free future updates.

Against the four jobs from your audit:

Job	What ships in LeadHub
Capture	19 native channels - Facebook Lead Ads, Instagram, TikTok, LinkedIn, Google Ads, web forms, Typeform, JotForm, Calendly, IMAP email parsing, an embeddable widget - with source, campaign and UTM tags attached on arrival
Pipeline	Drag-and-drop Kanban with custom stages, deal values and probability tracking; unlimited pipelines per workspace
Follow-up	Email sequences with delays, conditions, stop-on-reply, stop-on-won and open/click/reply tracking; an AI SDR agent that follows up every new lead by email until a human replies; automations for round-robin assignment, lead scoring, SMS, webhooks and Slack alerts; WhatsApp template automations
Bookings	Public booking calendar with two-way Google and Outlook sync, buffer time and availability rules; confirmations with 24-hour and 1-hour reminders

And the concession, stated as plainly as the pitch: LeadHub's Visual Flow Builder wires triggers to conditions and actions on a drag-and-drop canvas. It does not have wait steps inside flows, if/else branching, A/B splits or per-step statistics. If your audit flagged Core automations that depend on those, GoHighLevel keeps that win, and you should weigh it heavily.

Ownership has costs beyond the licence, and they belong on your audit sheet too. You provide the hosting - LeadHub runs on ordinary PHP 8.4+ and MySQL, including shared hosting, which typically costs a few dollars a month. You run updates yourself; the updater works from the browser with no SSH, but you click the button. You keep backups; verifiable database backups are built in, but restoring one is your job. And when something breaks at 9 p.m., there is no vendor status page to point at. For many small agencies that trade is easy. For some it is the entire reason to pay a subscription. Be honest about which one you are.

The Decision Rule

Take the one-page audit and apply a single rule:

Your Core bucket contains automations with waits, branches or splits that you would rebuild tomorrow if they vanished - GoHighLevel is worth it for you. Keep it, and stop feeling vaguely guilty about the invoice.
Your Core bucket is capture, pipeline, sequences and bookings - you are renting a deep platform to do shallow jobs, and the agency CRM decision reduces to economics: a compounding subscription plus usage rebilling, against a one-time licence plus cheap hosting.

The next step is not a purchase. It is the audit - this week, before the next invoice lands. If the Untouched column wins, see what LeadHub covers and run the price comparison yourself, on your own numbers.

RISE CRM Zapier: Practical Recipes for Freelancers and Agencies

Themesic Interactive — Fri, 04 Sep 2026 00:00:44 +0000

Every freelancer and small agency running RISE CRM eventually hits the same wall: the CRM knows things the rest of your stack does not. A lead lands in RISE and someone retypes the name and email into the mailing list tool. An invoice goes out and the figures get copied into accounting software by hand. The RISE CRM Zapier plugin exists to remove exactly that class of busywork by connecting RISE to the 7,000+ apps available through Zapier. Full disclosure up front: we build and sell this module at Themesic Interactive, so read this as a maker's walkthrough rather than a neutral review.

The pitch for Zapier-based integration is simple. Instead of waiting for someone to write a dedicated RISE integration for every tool you use, you get one bridge into Zapier's ecosystem of 7,000+ apps. If a service you depend on connects to Zapier, you can wire it to RISE CRM and let routine work run on its own. The headline number is not the interesting part, though. What matters is what the plugin actually exposes, and what you can realistically build with it.

What the RISE CRM Zapier plugin exposes

The plugin makes the core RISE CRM records available to Zapier in both directions, so data can flow into and out of the CRM automatically.

Triggers, where RISE starts the Zap:

New Lead - fires when a new lead is added in RISE
New Invoice - fires when a new invoice is created in RISE
New Client - fires when a new client is added in RISE
New Ticket - fires when a new ticket is created in RISE

Actions, where another app updates RISE:

Create a Lead in RISE
Create an Invoice in RISE
Create a Client in RISE
Create a Ticket in RISE

Four record types, both directions. That is a deliberately small surface, and it maps to the moments that matter commercially in a services business: someone shows interest (lead), someone commits (client), money is requested (invoice), and something needs fixing (ticket). The full catalog of apps you can pair these with is browsable on Zapier's integrations page for RISE CRM, which the product page links to.

Five recipes for freelancer and agency workflows

These are all built from the triggers and actions above, paired with app categories Zapier covers: accounting software, project management platforms, email marketing systems, team communication tools, SMS notifications, payment gateways, and so on.

1. New lead into your nurture sequence. The New Lead trigger fires the moment a lead is added in RISE, and Zapier hands the contact details to your email marketing system. Every inquiry starts receiving your follow-up sequence without anyone exporting a CSV or retyping an address. For a solo freelancer this is often the single highest-value Zap: leads go cold while you are heads-down on billable work, and this one keeps them warm on its own.

2. Invoices synced into accounting. The New Invoice trigger fires when an invoice is created in RISE, so Zapier can carry it into whatever accounting software you keep your books in. Manual double entry between a CRM and an accounting tool is where numbers drift apart; automating the sync keeps both systems telling the same story and removes a recurring source of errors.

3. Client onboarding kickoff. The New Client trigger fires when a new client is added. Point it at a project management platform and the win itself starts the onboarding motion: RISE stays the source of truth, CRM data is shared with the team members who need it, and task progress syncs to wherever your team already works.

4. Ticket alerts where the team actually looks. The New Ticket trigger fires when a ticket is created in RISE. Route it to a team communication platform, or to SMS notifications for the urgent stuff, and support requests stop sitting unseen in a CRM tab nobody had open. Small agencies rarely staff a dedicated support desk; this recipe is the cheap substitute.

5. Inbound records from anywhere. The actions run the reverse direction: any Zapier-connected service that captures contact or billing information can create a Lead, Client, Invoice, or Ticket in RISE. This is how you stop RISE from being the system that only knows what someone remembered to type into it. It also covers the extension scenarios the plugin is built for, like wiring in geolocation services or payment gateways to shape a CRM setup that fits how you actually operate.

You assemble all of these with Zapier's own tools, and the range runs from easy, straightforward connections to complex webhooks and triggers.

When a Zap is not enough: the built-in REST API

The plugin also inherits an optional REST API, which gives you a path to fully custom, programmatic integrations for anything the standard Zaps do not cover. The complete documentation describes the specific requests, responses, and parameters, and it is linked from the product page. One honest caveat that we state on the product page as well: supporting your custom code sits outside the scope of support. You get the API and the docs; what you build against them is yours to maintain.

Honest limits: when this is not the right tool

A few things to weigh before buying. The documented triggers fire on creation of those four record types - there is no documented trigger for updates, deletions, or other RISE modules, so a workflow that depends on reacting to, say, a record being edited will not work as a standard Zap. The REST API is the escape hatch there, but that means writing and owning code. Second, Zapier is a separate service with its own account and plans; this plugin gives RISE a connection into it but does not replace it. Third, this is a niche product with a modest track record: 37 sales on CodeCanyon and no published review count, so evaluate it on fit rather than crowd volume. And if your entire integration need is one specific pairing that already has a purpose-built native RISE integration, that dedicated route may be simpler than introducing a middleman.

Key facts

Fact	Detail
Current version	1.2b
Last updated	2026-05-04
Compatibility	PHP 8.x, PHP 7.x, CodeIgniter
Triggers	New Lead, New Invoice, New Client, New Ticket
Actions	Create Lead, Invoice, Client, Ticket in RISE
Extras	Optional REST API with full documentation
Track record	37 sales on CodeCanyon

Setup is deliberately boring: it takes only a few seconds to install and activate the plugin and have a working Zapier integration for RISE running. The changelog is short and maintenance-shaped - 1.0 was the initial release, 1.1 added PHP 8.x compatibility, and 1.2 plus 1.2b tracked compatibility with RISE CRM's latest versions - which is what you want from a bridge component: it should keep up with the platform and otherwise stay out of the way.

Links

If you run RISE and have a workflow you are not sure these triggers and actions can cover, describe it in the comments and we will tell you straight whether a Zap handles it or you are in REST API territory.

GoHighLevel SaaS Mode vs Owning Your Platform Outright

Themesic Interactive — Wed, 02 Sep 2026 00:01:02 +0000

At the top of GoHighLevel's pricing ladder - the tier commonly cited at roughly $497 a month as of mid-2026; always check their pricing page for current numbers - sits SaaS mode, the feature that turns the platform from a tool you use into a product you resell. GoHighLevel SaaS mode lets an agency put its own brand on the system, spin up sub-accounts for clients, set its own prices and collect its own subscriptions. It is the closest thing the agency market has to a turnkey "launch your own CRM SaaS" button, and plenty of agencies run real businesses on it.

One thing before anything else: we build and sell LeadHub, a self-hosted multi-tenant CRM script that competes with this model directly, so weigh everything below with that in mind.

The question worth asking is not "can I resell a CRM under my brand?" - both routes answer yes. The question is "what do I actually own when I do?" The answer changes the economics at every scale, which is why this article walks them at 10, 30 and 100 client workspaces instead of arguing in adjectives.

What GoHighLevel SaaS mode genuinely delivers

Credit first, because it is real and the reader has usually seen it firsthand.

A mature automation engine on day one. GHL workflows support wait and delay steps, if/else branching, A/B split testing and per-step analytics. That is deeper than what we ship: LeadHub's Visual Flow Builder wires triggers to conditions and actions on a drag-and-drop canvas, and it does not have wait steps, branching or split tests inside a flow today. If your resale pitch depends on demonstrating a twelve-step branching journey to a prospect, GoHighLevel hands you that on day one and we do not.

Uptime is someone else's job. Servers, scaling, patching, database maintenance - all invisible to you. When you resell through GHL, you sell software you never have to operate.

The reseller mechanics are built in. SaaS mode includes tooling to charge your sub-accounts, and as commonly configured it lets you rebill usage such as email and SMS with a markup. Becoming a white-label SaaS operator takes configuration, not construction.

What stays someone else's - permanently

None of what follows is a hidden flaw. It is the structure of every white-label arrangement, stated plainly.

The platform. You cannot self-host GoHighLevel. The code is not yours, and your clients' data lives on their infrastructure.
The pricing floor. Your margin sits on top of the subscription - roughly $497 a month for the SaaS-mode tier, as commonly cited - plus usage costs that flow through the platform wallet. If the subscription or the usage rates change, your cost base changes with them.
The feature set. What your branded product can do is decided by the vendor's roadmap. Features arrive, change or retire on their schedule, not yours.
The terms. Your customers are sub-accounts of your account. The agreement that ultimately governs the whole stack is between you and the vendor, and vendors can amend terms.

A reseller with a healthy margin is still a reseller. Distribution is a legitimate business - but it should be a decision you made, not a default you drifted into.

Owning the platform inverts each of those

Ownership here means something specific: LeadHub ships as complete, unencrypted Laravel source code that you install on your own server through a browser-based installer - no SSH, no Composer. From that point the inversion is one-to-one:

You set the plans. The super-admin plan builder creates tiers with per-plan feature gates, usage limits and seat caps: lead sources, the AI Lead Coach, marketplace installs, white-label, API access and webhook quota are all switches you flip per tier. Feature flags can hide entire admin sections from a plan - Reports, Brand and Domain, Communications, Advanced, Tools and Templates - so your $29 tier literally cannot see what your $99 tier gets.
You keep the whole subscription. Payments run through your own accounts on any of five gateways - Stripe with Hosted Checkout and recurring subscriptions, PayPal, Razorpay for India, Paystack for Sub-Saharan Africa, or manual bank transfer with super-admin confirmation. There is no platform between your customer's card and your bank.
You run the promotions. Coupons support percentage and fixed discounts, trial extensions, usage limits, date ranges and plan restrictions. Free trials expire automatically, and escalating dunning emails chase failed payments without you touching anything.
You grow it like a SaaS. A built-in affiliate engine tracks referral codes with a recurring 20% commission and a payout audit trail, while the super-admin dashboard reports MRR, ARR, churn and lead-source mix.
Your brand is the only brand. Each tenant workspace renders with the tenant's own logo, colors, app name, favicon and footer, and the platform underneath renders with yours. To resell a CRM under your brand here is not a mode - it is the architecture.

GoHighLevel SaaS mode cost vs ownership: 10, 30, 100 workspaces

Assume you charge each client workspace $97 a month. Your number will differ; the shape of the comparison will not. Payment processing fees and your own selling costs land in both columns, so we leave them out.

	10 workspaces	30 workspaces	100 workspaces
Monthly revenue at $97/workspace	$970	$2,910	$9,700
GHL SaaS mode platform cost	~$497 + usage wallet	~$497 + usage wallet	~$497 + usage wallet
Self-hosted platform cost	VPS, ~$20-40	VPS, ~$40-80	VPS, ~$80-160

The server figures are typical mid-2026 VPS pricing and your stack may differ; the one-time licence is a real cost too and should be amortised over the first year. With that said, two things jump out of the table:

The subscription hurts most when you are small. At 10 workspaces, roughly $497 is more than half your platform revenue before a single usage charge. At 100 workspaces it is about 5% and barely matters. The flat fee is a tax on starting, not on scale.
Usage is the cost that scales. Every email and SMS your 100 workspaces send flows through the platform wallet at platform rates, every month, indefinitely. Self-hosted, email goes out through your own SMTP and calls and texts go through your own Twilio or Plivo account - chosen per workspace, with Plivo notably cheaper in India and many regions - at direct provider rates.

So the honest summary is not "ownership always wins". It is: at small scale the subscription dominates and ownership pays back fastest; at large scale the subscription is trivial and the comparison becomes usage rates, terms and control.

The trade: ownership makes you the vendor

SaaS mode takes operations off your plate. Ownership puts them back on. When you run the platform, you apply the updates, keep the backups, secure the server and answer the support tickets. Tooling can shrink that responsibility, not delete it. What ships to shrink it:

Browser-based updates that run database migrations and clear caches without SSH, plus shared-hosting essentials like URL-based cron and a sync mail driver for hosts without queue workers.
One-click tenant impersonation - 60-minute audited sessions with a full audit trail - so you can see exactly what a customer sees without ever asking for a password.
Verifiable, downloadable database backups, audit logs with configurable retention, and a health endpoint that probes database, cache and storage with a 200/503 response your monitoring can watch.
Self-running lifecycle email - dunning escalation, plan-limit alerts as tenants approach caps, and trial-expiry notices.

Be equally honest with yourself about the automation gap, because your tenants will compare notes with GHL users. LeadHub flows are trigger-condition-action, without waits, branches or A/B splits. What carries the follow-up load instead: email sequences with delays, conditions, stop-on-reply, stop-on-won and open/click/reply tracking; an AI SDR agent that follows up every new lead by email until a human replies; booking confirmations with 24-hour and 1-hour reminders; marketing automations that handle round-robin assignment, lead scoring, SMS, webhooks and Slack notifications; and WhatsApp template automations for reaching a brand-new lead outside the 24-hour window. For most tenants, that set covers the automation they actually use. For a tenant whose business runs on branching journeys, it does not - and you should send that tenant to GoHighLevel with a clear conscience.

A decision rule you can run this week

Count the workspaces you can realistically bill within 90 days. Below roughly 15, the flat subscription is your single biggest platform cost, and ownership pays back exactly where SaaS mode is most expensive relative to revenue.
Write down the three automation features your sales demo depends on. If wait steps, branching journeys or A/B-tested follow-up are on that list, GoHighLevel SaaS mode is the honest choice today.
If the list is capture, pipelines, sequences, booking and billing, price ownership properly. Licence plus VPS plus your own SMTP and Twilio or Plivo rates, against subscription plus wallet usage at your real monthly message volume.
Decide who you can afford to have reprice you. Whatever the spreadsheet says, this question determines how the next five years of your platform business feel.

If ownership wins your numbers, LeadHub is our version of it - one purchase, your server, your gateways, your plans. If SaaS mode wins, you have at least decided rather than defaulted, and that alone puts you ahead of most of the market.

Anatomy of a Multi Tenant SaaS CRM PHP Stack: A LeadHub Tour

Themesic Interactive — Wed, 02 Sep 2026 00:00:43 +0000

The build-vs-buy question for a CRM product has a specific shape in the PHP world. If you have ever scoped a multi tenant SaaS CRM PHP build, you know the lead table and the CRUD screens are the part you finish in a sprint. What eats the rest of the year is everything around them: tenant isolation, plan gating, subscription billing with tax-compliant receipts, signed webhooks, GDPR workflows, and every lead source your first paying customer asks about in week one.

Full disclosure: we build and sell LeadHub, the product this article walks through. Treat it as an architecture tour rather than a pitch - an inventory of what a shipping multi-tenant CRM script actually contains. LeadHub is a self-hosted Laravel 13 application with a Filament 4 admin panel, Livewire 3 reactivity and Tailwind CSS, shipped as complete unencrypted source with no IonCube, currently at version 2.0.9 (updated 2026-07-30).

Tenancy first: the multi tenant SaaS CRM PHP architecture

LeadHub treats the tenant, not the user, as the primary unit. Each tenant is a workspace with its own leads, pipelines, automations, sequences, forms, calendar and team, and isolation is enforced at the query level so tenants do not see each other's leads, deals or settings. Access control spans six roles - super-admin, tenant owner, tenant admin, staff, viewer and customer - with granular permissions below that.

White-labeling is per tenant and covers the details that usually leak: logo, favicon, app name, footer links, and primary and accent colors flowing through the dashboard, admin panel, widget, forms, landing pages and emails. Each workspace also gets public surfaces that work without login: landing pages built from reusable blocks, shareable forms, a booking calendar with two-way Google Calendar and Microsoft Outlook sync, and team contact pages.

Above the tenants sits a super-admin panel where the platform owner builds plans with feature gates and usage limits, manages tenants, configures gateways, and watches MRR, ARR and churn. Two operator details stand out. One-click tenant impersonation runs as a 60-minute audited session, so you can troubleshoot a tenant without ever asking for a password. And plan feature flags can hide whole admin sections from the tenant admin per tier, so cheaper tiers simply see a smaller product. The panel itself can be locked to specific IP or CIDR ranges.

Web-to-lead capture from nineteen channels

Lead capture is where a hand-rolled CRM quietly becomes a maintenance treadmill, because every channel is its own integration. LeadHub ingests from nineteen channels natively. Social and ads cover Facebook Lead Ads, Instagram, TikTok, LinkedIn, X/Twitter, Snapchat and Pinterest; messaging covers WhatsApp, Viber and Telegram; paid search covers Google Ads, YouTube and Microsoft Ads; and the inbox-and-forms bucket covers IMAP email parsing, Typeform, JotForm, Calendly bookings and web forms. Manual entry adds bulk CSV import, copy-paste bulk add and a single-lead form, and a dedicated parser turns IndiaMART and Justdial directory enquiries into structured leads.

For your own properties there are three routes in. An embeddable JavaScript widget drops a branded capture form onto any website from a single snippet, matching the tenant's brand colors and submitting cross-origin to the LeadHub backend, with multi-step support, file uploads and reCAPTCHA. Public shareable forms add conditional logic, QR codes and branded thank-you pages. And a RESTful API exposes leads, pipelines, deals, forms, automations, sequences and webhooks behind scoped API keys, with per-tenant rate limiting (60 requests per minute by default, configurable per plan) and interactive docs in every tenant dashboard.

Whatever the source, a lead arrives with its context attached: source, campaign, UTM tags, assigned user, pipeline stage, score, custom fields and a complete activity timeline.

Pipelines, sequences and a visual automation engine

The working surface is a drag-and-drop Kanban board with custom stages, colors, deal-value tracking and probability percentages; each tenant can create unlimited pipelines, so sales, onboarding, support and recruiting flows live side by side. A scoring engine reacts to field, behavior and engagement triggers, duplicate detection uses configurable email and phone fuzzy matching with a merge workflow that preserves activity history, and win/loss reasons are captured at close.

Marketing automations follow a trigger, condition and action model - round-robin assignment, lead scoring, SMS, webhooks and Slack notifications - and a Visual Flow Builder wires those nodes on a drag-and-drop canvas instead of a settings form. Email sequences run with delays, conditions, stop-on-reply and stop-on-won behavior plus open, click and reply tracking. Click-to-call and SMS run through Twilio or Plivo, chosen per workspace; calls are logged with status and duration, and Twilio calls add recording with AI transcription and summary.

Outbound webhooks fire on events such as lead.created, lead.stage_changed, deal.won, form.submitted and automation.triggered, with replay-safe HMAC signatures, secrets encrypted at rest, delivery logs, retry tracking and dead-letter alerts. There is also an optional AI layer - next-best-action suggestions, draft replies, score reasoning, an embeddable website chatbot and an autonomous email follow-up agent - but it is plan-gated, and the CRM runs fully without any LLM key.

Billing that survives an accountant

Monetization is built in rather than bolted on. Five gateways ship out of the box: Stripe with Hosted Checkout, the Customer Portal, recurring subscriptions and webhook idempotency; PayPal via the billing-subscriptions API with signed-webhook verification; Razorpay for the Indian market; Paystack for Sub-Saharan Africa; and manual bank transfer with super-admin confirmation. Plans carry monthly and annual pricing with a configurable annual discount, seat caps and usage limits; coupons support percentage or fixed-amount discounts, trial extensions and plan restrictions.

The details are the point. Receipts are sequentially numbered (LH-YYYY-NNNNNN) with EU VAT, US sales tax and per-tenant currency, refunds auto-generate negative credit notes, trials expire automatically, and dunning escalates payment-failure emails toward suspension. An affiliate engine tracks referral codes with recurring 20% commissions and a payout audit trail. If you have ever written invoice numbering and VAT logic by hand, you know how much of a build this one section represents.

Running it: shared hosting, security and GDPR

LeadHub is deliberately deployable where a lot of PHP still lives: shared hosting. A browser-driven installer handles setup with no SSH and no Composer, updates run migrations and clear caches from the browser, URL-based cron works with cPanel, an optional sync mail driver covers hosts where queue workers cannot run, and a health endpoint probes database, cache and storage with a 200 or 503 response. It needs PHP 8.4 or higher (8.5+ recommended), MySQL 5.7+ or 8.x with MariaDB 10.3+ supported, and Apache or Nginx.

Security includes TOTP two-factor authentication with recovery codes and per-role enforcement, an atomic cache-based brute-force lockout, trusted-proxy IP resolution behind Cloudflare or Nginx, and a password policy with a breach-database check on signup. The compliance suite covers an Article 28 data processing agreement as a public download, a cookie consent banner, Article 20 data export as a full ZIP, and Article 17 erasure as a 30-day cool-off workspace deletion. Retention policies purge audit logs, login attempts and webhook events, and tax receipts deliberately survive tenant erasure to meet the legally required 7-10 year retention.

When you should still build your own

An honest note, because this is where marketing pages usually go quiet. LeadHub is a Laravel application; if your team lives in Node, Python or Go, adopting a large PHP codebase carries a real cost even with clean source. Isolation is enforced at the query level inside one shared application, so if your compliance regime demands a physically separate database per tenant, this architecture is not that. It is also a commercial script rather than a community open-source project, and a young one at 27 sales on CodeCanyon, so you rely on vendor updates rather than a large third-party plugin ecosystem. And if the CRM itself is your differentiator, owning every line may justify the build time. LeadHub fits when the CRM is the vehicle rather than the product: an agency consolidating client leads, an internal sales team, or a niche SaaS where your edge is distribution and vertical fit, not pipeline plumbing.

Links

If you are weighing a build against this, or want more detail on any subsystem above, ask in the comments - happy to go deeper on the tenancy or billing internals.