How to Connect Two Software Systems That Don't Talk to Each Other

Most companies choose best-in-class tools for each function - CRM, project management, billing - then discover they don't talk to each other. Sales pipeline data sits trapped in one system while fulfillment workflows run in another. Updates that should flow automatically require manual re-entry instead.

The standard fixes aren't realistic for mid-sized operations: hiring a team of integration engineers costs too much, and enterprise integration platforms often price themselves out of reach.

This guide walks through five practical approaches to connect two software systems, with honest assessments of what each costs, where it breaks down, and which businesses it actually fits.

Five approaches to connecting software systems

The five approaches to connecting software systems are no-code/low-code platforms (Zapier, Make, Workato), direct API integration with custom code, custom middleware solutions, automated CRM-to-accounting workflows, and hybrid approaches that combine multiple methods depending on complexity, volume, and business logic requirements. Each approach trades off speed, cost, control, and maintenance burden differently.

No-code/low-code platforms (Zapier, Make, Workato)

No-code/low-code integration platforms allow setup of integration within minutes by creating actions and combining them into a workflow. Actions are set up by filling in the fields for the selected application, for example selecting the application to trigger from, the data to pass through, and the application where a new deal will be created. According to Zapier's pricing page (2026), the Professional plan includes 750 tasks per month for $19.99 per month on annual billing. Make offers a free tier and usage-based paid plans - see Make.

The advantages: integrations can be set up quickly. However, there are limitations. Users are bound by the field structures in their CRMs and it will be hard to set up complex data transformations that need conditional logic across 6 fields. Teams might run into problems with the number of tasks allowed per plan. If there are 500 new contacts per day that all need to be added to another CRM, the 750 tasks will be used up within a day and a half.

Direct API integration (custom code)

This approach writes a script in a programming language, for example Python or Node.js, to integrate with the REST API of both systems directly. Full control of the integration is possible. The data can be transformed as needed, and sent to the target system as required. Records can be sent in batch to avoid hitting rate limits, and custom retry logic with exponential backoff can be implemented.

The tradeoff is maintaining the code.

Using no-code platforms

No-code platforms like Zapier or Make work best for simple linear workflows such as creating a QuickBooks invoice for every closed Salesforce opportunity, using trigger-action principles without complex data manipulation, with plans starting at 100 tasks per month free or 750 tasks for $19.99 monthly on the Professional tier. Complex conditional logic becomes difficult to manage through Paths (if/then/else statements), error handling is limited to email notifications when systems go down, and costs escalate rapidly - a 5-step Zap running 500 times monthly consumes 2,500 tasks, requiring a higher-tier plan.

Simple linear workflows such as 'For every new closed opportunity in Salesforce, automatically create a new invoice in QuickBooks' can be easily implemented with no-code platforms. Such workflows are mostly based on a trigger-action principle and do not require a lot of data manipulation.

Here is a summary from Zapier's pricing page (2026) for the Free plan for a solo user. It supports a 2-step workflow and up to 100 tasks per month.

Limitations become apparent quickly.

Conditional logic is challenging - at least, complex conditional logic is. Usually setting up a conditional in a zap is simple, but for more complex rules, the use of Paths can be the only way to set up the conditional. Paths are a series of if/then/else statements that are set up in straight lines of rules that are to be executed. Reading through the conditional logic Paths can be difficult enough to troubleshoot, but the more complex the conditional the more difficult the setup and troubleshooting become.

No-code platforms have limited error handling should something go wrong in a task. If QuickBooks is down for 2 hours, then the no-code platform will fail the task and send an email notification for the user to then manually re-sync the affected data.

Cost will typically trump feature limitations as the deciding factor. According to Zapier's pricing page (2026), the Professional plan is $19.99 per month on annual billing to process 750 tasks. Running a 5-step Zap 500 times per month would equal 2,500 tasks per month. In this case, a company would need to move to a higher-tier plan to accommodate the task count.

Using direct API integration

Direct API integration involves writing custom code in Python or Node.js to send HTTP requests directly to each system's REST API endpoints, giving full control over data mapping, transformation, field calculations, date formatting, and real-time syncing via webhooks with no per-task fees beyond hosting costs once built. Authentication is established through API keys or OAuth tokens, data is pulled via GET requests, transformed according to business rules, and posted to target endpoints, with complete control over pagination, retry logic, conditional discounts, multi-currency conversion, and tax calculations.

If there are no connectors available or the connectors that are available do not support the necessary functionality, custom code can be created to send HTTP requests to the REST API endpoints of the systems being integrated. Initially, API keys or OAuth tokens are set up for authentication. Then the necessary data is pulled from System A by sending a GET request. After that the data is transformed (for example: map fields, calculate values, change date format). Then all the data is posted to the corresponding endpoints of System B. This way full control is gained over the data and the processing that occurs between the systems.

To start, an API key is received from HubSpot's account settings. Xero uses OAuth2 for authentication and requires exchanging the client ID and secret for an access token. After authentication, the Deals API is then used to fetch the data of closed deals in System A. HubSpot's API returns JSON with all the deal properties. If there are multiple pages of closed deals then pagination must be handled.

Map the HubSpot fields, such as hs_deal_amount to the corresponding Xero fields, such as Total. Then calculate any additional fields, such as tax based on business rules. Format dates to match Xero's requirements (ISO 8601 format). After that, use all this information to create a new invoice by posting a POST request to the Invoices endpoint in Xero. Also, log any events that occur during this process.

The advantages are significant.

Custom code can sync in real-time by adding a webhook to the close of deals event. This then fires off the code to write invoices and other required data in other systems such as Xero in real-time. This gives full control over how deals are transformed into invoices for example writing in conditional discounts, multi-currency conversion rates, tax rules etc. The best part is that there are no per-task fees to process thousands of records daily once the code has been written, and it will run for free (other than normal hosting costs) - contrast this with the rising cost of tasks in services such as Zapier.

Building custom middleware

Custom middleware acts as a central translator and traffic cop that performs data transformation, routing, validation, error handling, retry logic, and logging, making it valuable when connecting three or more systems, managing frequently changing business logic, requiring transactional integrity where no record can be lost, or needing full audit trails for every step. The middleware receives data from source applications via API or webhook, validates it against business rules, transforms it to the correct format, routes it to destination systems, and logs every step - ensuring that if any step fails, nothing is committed and transactions remain in a pending queue.

Although a middleware architecture can be complex to understand and to architect, once teams know when to use it they can save a lot of time. The architecture is useful in four situations: (1) Three systems or more need to be connected (e.g. CRM, accounting, stock management, shipping management); (2) Business logic frequently changes and is hard coded in every system; (3) Transaction loss is not acceptable (e.g. financial records, order completion records etc.); (4) An audit trail of all steps for every record is needed. For simple synchronization of two systems the APIs of both systems and direct iPaaS connections are sufficient and do not create an overhead.

Below is a step by step process of how such architecture could be set up to connect two software systems. In this example the source application is "pushing" the data via an API or Webhook to the middleware service. The data then gets validated based off pre-defined business rules for that specific data. After validation the data will then get transformed to the correct data structure or format for the destination systems. After transformation the data will then get routed to the correct applications. Logging occurs at every step in the process. If an error were to occur in the processing of a transaction audit logs would be available to identify what happened to the failed records.

This transactional integrity is a big differentiator for this architecture vs. point-to-point integration.

Here is an example of a very simple workflow in which the middleware is handling a transaction from one system to another. In this example an ecommerce order arrives in the system. First the middleware checks whether there is enough stock of the items required in the warehouse. This is a call to a web service via an API. Next the middleware determines the shipping cost for the order. Again this is a web service call, this time to the FedEx API. Next the middleware creates an opportunity in Salesforce. Then it creates an invoice in QuickBooks. And finally it posts a notification to a Slack channel. The middleware processes all of this in a single transaction. If the API call to QuickBooks fails for whatever reason, then nothing at all is committed, and the order is left in a pending queue until the problem is fixed.

Worth considering? Usually. Not always, but usually.

Automating CRM-to-accounting workflows

CRM-to-accounting automation connects systems like Salesforce and QuickBooks to automatically create invoices when deals close, with no-code platforms handling low volumes (Zapier's Professional plan allows 750 tasks monthly for $19.99) while high-volume or complex scenarios requiring real-time processing, custom payment terms, multi-currency support, or validation rules need custom API integration or middleware. Custom implementations use Salesforce webhooks to trigger validation (checking billing contacts and Tax IDs), transform and map data correctly, post to the accounting system's API, and store the resulting invoice number back in the CRM, requiring error handling, retry logic, and monitoring tools like Airflow.

The most common integration that businesses set up is Salesforce CRM and QuickBooks financials. Typically, automating the process of closing a deal in the CRM and automatically creating an invoice in the accounting package for that customer. If there are only a handful of customers per month then these types of no-code automation flows are perfectly fine to automate tasks. However, the biggest assumption that Salesforce will inform an integration of all customers who need to be invoiced is not true. For every update to an Opportunity in CRM, the Opportunity will go through all of the stages that are required for an Opportunity to go through for that Opportunity to be closed as a "closed-won" deal. So, a task could be set up to automatically create an invoice in the customer's accounting package every time that the Opportunity is updated. But, filters would need to be added for the different fields on the Opportunity to make sure that tasks are only created for closed-won deals and not for all of the other updates for all of the other stages of the Opportunity. And even with the filtering, the limits for the number of tasks per month for the Professional plan for no-code automation would be reached very quickly.

If invoices are being sent out automatically in real time, or if there are rules around payment terms for different customers (e.g. net 30 days for one customer and net 60 days for another), or partial payments, or even multi-currency scenarios, then no-code workflows are not enough and an integration needs to be built.

An implementation like this would typically be set up as custom API integrations between the systems, typically deployed as middleware that acts as a proxy to abstract away any complex data transformations required between the source and target systems. On trigger of the Salesforce webhook within a record automation in the CRM, validation rules are put in place to for example check whether the correct billing contact has been set by the sales rep as well as whether the Tax ID number for this contact has been filled in correctly. After successful validation, all relevant data is then mapped and transformed in the correct format to be posted to the target system's API. Once the invoice has been successfully posted within the target system, the corresponding invoice number is retrieved and stored against the corresponding opportunity record in the originating system.

Building such an integration is not a weekend project and has to deal with several issues, e.g. error handling, retry logic for QuickBooks API timeouts, monitoring whether the integration worked or not. Such workflows can be managed with tools like Airflow. But for larger volumes of customers it is worth it to invest.

Frequently Asked Questions

What is it called when two software programs work together?

Integration. When two systems share data automatically (e.g. a CRM is filling new leads into an email program) that is integration going on in the background. Integration is the plumbing behind automation.

What is an example of software integration?

Examples of software integrations include: Connecting up Salesforce CRM and email tool such as HubSpot (leads automatically upload into CRM for sales teams). Payments processing with Stripe integrating into online accounting package such as Xero or QuickBooks Online (each payment automatically generated into the package as an invoice for example).

What if one or more of the software programs do not have an API?

If no API is available for either system, hopefully the systems support webhooks. Zapier and Make can be used for such integrations as well. Also, it is possible to set up such integrations via scraping export data from the first system and then import that data into the second system (very error prone and inelegant, but works). Sometimes, it makes sense to build a custom connector (data is pulled directly from database of the first system).

How long does it take to integrate two software systems?

Depends entirely on what systems are being connected. A simple integration of two applications that many people use such as Salesforce.com and HubSpot.com (e.g. leads in Salesforce.com automatically added as contacts in HubSpot.com) can take a few hours to a day to set up, assuming the user has clean data. A more complex API integration with data transformation and error handling can take 1-2 weeks or more for a single integration.

Can you integrate systems that use different programming languages?

Yes. It doesn't matter what languages the applications were built with. As long as the systems expose APIs, then it is possible to connect two software systems via a service - usually a RESTful service.

What's the difference between integration and automation?

Integration is when two systems can share information automatically in real time between them. Automation is when the integrated systems are used to automate processes automatically, such as when a new deal is added into Salesforce CRM and automatically sends out a welcome email to that new deal.

Gable Innovation is a technology consultancy that helps growing businesses connect their systems, automate workflows, and build custom integrations when off-the-shelf tools don't cut it. To discuss your options around building, buying, or hiring for your integrations book a 30 minute discovery call at gableinnovation.com.