Skip to main content
FreeAn audit of your Drupal siteA written audit of your Drupal site, within three business days
All articles

Frontend & SDXNov 2, 20265 min read

Connecting your website to the systems you already run

Valentin ZsigmondFounder & Lead Engineer

A website rarely stands alone. Behind most business sites there is an invoicing system, a CRM, a stock database, a newsletter tool, a booking calendar or an accounting package, and the value of the site multiplies when it talks to them. A form that creates a lead in the CRM instead of an email. A product page that shows real stock. An order that becomes an invoice without anyone retyping it. This year in Romania, the e-Factura rollout made the last of these concrete for tens of thousands of small businesses: since July, nearly every invoice must reach the national system as structured data within five working days. Integration stopped being a nice-to-have and became part of running a business. This article is about how we connect a Drupal site to the systems you already run, and why those connections stay reliable.

The shapes integrations take

Most integrations are one of four kinds, and knowing which you need is half the design.

The site sends. A form submission becomes a CRM lead, a ticket in a helpdesk, a subscriber in a mailing list, a row in a spreadsheet. The site is the source; the other system receives.

The site receives. Products, prices, stock, opening hours or job listings live in another system and appear on the site. The site is a display for data it does not own, refreshed on a schedule or when the source changes.

The site orchestrates. An order placed on the site reserves stock in one system, takes payment through another, creates an invoice in a third and submits it to e-Factura, then notifies the customer. The site coordinates a sequence across several parties.

The site exposes. A mobile app, a partner or a reporting tool reads the site's content through an API. The site is the source for others.

Why Drupal is comfortable here

Drupal was built as a framework as much as a CMS, and integration is where that shows. Its content is structured, so mapping a product record from an external system onto a product on the site is a field-to-field exercise rather than a parsing problem. Its queue system lets work that talks to other services run in the background, retry on failure and never slow down a visitor. Its API layer exposes any content type to other systems with permissions enforced. And its module system means each integration is a self-contained piece with its own configuration, tests and logs, which can be updated or replaced without touching the rest of the site.

That last property is the one that matters over years. External systems change: an API version is retired, a provider is replaced, a field is renamed. An integration built as a module is a small thing to update. One woven through templates and custom code is a project.

Designing for the day the other system is down

Every integration involves a system you do not control, and every one of them will be unavailable at some point. Good integrations are designed for that day from the start. If the CRM is unreachable, the form still submits, the lead is queued, and it is delivered when the CRM returns; the visitor never knows. If the stock service times out, the product page shows the last known stock with a timestamp rather than an error. If the invoicing system rejects a submission, a person is notified with the reason, and the order is not lost. The rule is simple: the visitor's experience should never depend on a third party answering in time.

The same principle governs security. Credentials for external systems are stored as secrets outside the code, scoped to the environment, so staging can never reach a live invoicing account. Every call is logged. Data sent to another system is the minimum that system needs. And the connection is monitored like any other part of the site, so a failing integration is noticed before a customer notices a missing invoice.

The e-Factura example

The Romanian e-invoicing requirement is a good illustration because it touches every part of the pattern. An invoice has to be generated as structured XML in a specific format, signed, submitted to the national system, and the response recorded, with a deadline attached. For a business whose orders originate on its website, the natural place for this to happen is the moment the order is confirmed, in the background, with the result visible to the finance team and the customer.

Whether the invoice is produced by the site itself or by an accounting package the site feeds, the integration has the same structure: a queue, a mapping, an idempotent submission that can be safely retried, a record of the response, and an alert when something is rejected. We build it so that the finance team sees every invoice's status in one place, and so that a change in the format, which has happened more than once, is a change to one module.

Integrations inside a portal

Where a business has a client portal, integrations become its main content. Orders from the shop, invoices from accounting, tickets from support and documents from a file system appear side by side, each fetched from its own source and shown under the same permissions. Our own portal works this way, pulling from several internal systems, and the pattern scales down to a customer area with a single connected system.

Starting an integration project

We begin with the data, not the technology: which records need to move, in which direction, how often, and what should happen when it fails. Then we look at what the other system offers, read its documentation, and build a small proof that moves one real record end to end. Most integrations are live within a few weeks; the ones involving payment or invoicing take longer because they involve certification and testing against a sandbox. Throughout, the work is visible in the portal and testable on staging with scrubbed data, never against live accounts.

If your team is retyping information from the website into another system, or from another system onto the website, that is an integration waiting to be built. Tell us which systems are involved, and we will tell you what connecting them would take.

Written by

Valentin Zsigmond

Founder & Lead Engineer

Full-stack Drupal architect with almost two decades of experience leading large teams in enterprise environments. Founded Tilizy Digital to bring senior-level expertise directly to the organizations that need it. Mentor to dozens of Drupal developers and creator of SDX — a Drupal extension for building modern frontends with React and Vue.

Enjoyed this article?

If this resonated, imagine what we could do working together on your Drupal site.