Integrations · APIs · Middleware

Custom integrations for your business systems, without having to start over in two years

We build integrations between your ERP, CRM, e-commerce, payment, shipping, accounting, CMS and identity systems that don't break with every supplier update. From simple API integrations to multi-system middleware with audit trail, error handling and monitoring — pragmatic, vendor-independent and honest about what it solves.

Why integrations so often become fragile

An integration that was set up in 2 days ends up, 4 years later, in a spaghetti architecture that nobody dares touch. We often get called in at the moment one integration piece in the chain has failed and suddenly the whole business grinds to a halt.

Hardcoded credentials and endpoints

The integration never had central configuration. Every supplier change requires a code deploy. Migrating to a new environment is a puzzle.

No audit trail

Who forwarded which order? When did the stock sync last run? When data doesn't match, tracing the cause takes hours of work.

No retry or error handling

One API call fails and the chain stalls. No dead-letter queue, no retry with backoff, no alert to a human if something keeps happening.

Tightly coupled one-to-one

Does a supplier change their API? Then your integration has to be adapted. There is no abstraction layer between your business logic and the external service.

Maintained by nobody

The engineer who built it has left. Documentation is sparse. Bugs get hot-fixed; technical debt keeps piling up.

Performance doesn't scale

The integration worked at 100 orders a day. Now it's 50,000 — the batch job hangs for 6 hours, rate limits are hit, and the supplier blocks the IP.

Integration categories we regularly work in

Below are the domains in which Appfront builds integrations. In every category we have ongoing projects, with sector experience and concrete pattern libraries.

ERP & accounting

Exact, AFAS, Unit4, Microsoft Dynamics 365, SAP Business One, Snelstart, AccountView, Twinfield. Order, invoice, stock and general ledger integrations with an audit trail.

CRM

Salesforce, HubSpot, Microsoft Dynamics 365 Sales, Pipedrive, Zoho. Lead routing, account sync, opportunity events and activity logging from other systems.

E-commerce

Shopify, Magento, WooCommerce, BigCommerce, Lightspeed, Shopware. Catalogue, stock, orders, fulfilment, webhook events and headless storefronts.

Payment & PSP

Mollie, Stripe, Adyen, Buckaroo, Pay., Worldline. Payment initiation, settlement import, recurring billing, refund flows and reconciliation with your accounting.

Shipping & fulfilment

PostNL, DHL, DPD, GLS, UPS, Sendcloud, Shipstation. Label generation, tracking events, returns flows and shipment status in your customer portal.

Document automation

PandaDoc, DocuSign, Proposify, Adobe Sign. Template rendering, e-signing flows and archive integrations for quotes, contracts and compliance documents.

Communication & CPaaS

Twilio, MessageBird, Vonage, Pinger. SMS, voice, WhatsApp Business and OTP flows with retry, fallback and compliance logging.

Identity & SSO

Microsoft Entra ID (Azure AD), Okta, Auth0, Google Workspace, Keycloak. SSO, SCIM provisioning, MFA and role mapping to internal applications.

Marketing & analytics

Klaviyo, Mailchimp, Brevo, ActiveCampaign, Segment, GA4. Event tracking, contact sync, transactional emails and consent-managed flows.

HR & payroll

AFAS, Nmbrs, Loket, BambooHR, Personio, Visma. Employee events, leave integration, payroll import into your accounting and SSO to the HR portal.

CMS & PIM

Directus, Strapi, Sanity, Contentful, Storyblok, Akeneo, Pimcore, inriver. Content and product sync to storefronts, mobile and marketplaces.

Custom & legacy

SOAP services, EDI (EDIFACT, X12), AS/2, SFTP feeds, on-premises databases, legacy SAP systems. By putting a modern API layer on top, we make them accessible to modern applications.

Our approach: integrations that last

Not all integrations are equally critical. An ad hoc CSV import for a one-off migration doesn't need an audit trail; a real-time order flow between a webshop and an ERP does. We scale our approach to the impact of the integration.

1

Discovery & data mapping

1-3 weeks: we map fields, identify transformation rules, validate what is possible and permitted in both systems, and assess risks. Output: an integration blueprint with scope, phasing and effort.

2

Choosing the pattern

For each integration we choose the right pattern: real-time API, webhook-driven, batch sync, event bus or a hybrid. Pragmatically, based on volume, latency requirements and operational complexity.

3

Built with first-class concerns

Centralised authentication, retry with backoff, idempotent endpoints, a dead-letter queue for permanent failures, an audit log per request, and a design that is aware of rate limits. No afterthoughts.

4

Test and sandbox environments

Sandbox credentials for vendor APIs, mock servers for offline tests, end-to-end smoke tests in CI. No "we'll test in production and hope it works".

5

Gradual rollout & monitoring

Feature-flag-driven rollout to 5%, 25% and 100% of flows. Dashboards for success rate, latency and error types. Alerts to the right owner when anomalies occur.

6

Documentation and knowledge transfer

ADRs for architecture decisions, runbooks for operations, and handover sessions with your team. By the end of the project, your team should be able to run the integration independently, with our remote support for anything that still needs it.

Integration patterns we use regularly

No one-size-fits-all. For each integration we choose the pattern that fits the volume, latency, complexity and budget.

Direct API integrations (point-to-point)

For single integrations between two systems with manageable traffic. Fast, simple, few moving parts. A sensible choice as long as you are connecting no more than 3-4 systems.

Middleware / iPaaS

For 5+ systems, or where transformation and orchestration logic becomes complex: a dedicated middleware layer or an iPaaS platform (Mendix, Boomi, Workato, n8n). One place for flow design, monitoring and versioning.

Event-driven via a message bus

Order, stock and customer events on a bus (Kafka, RabbitMQ, Azure Service Bus). Consumers scale independently, retries and dead-letter handling are built in, and you get an audit trail for free.

API gateway with service orchestrator

For complex enterprise scenarios with multiple customers and service levels: a gateway for routing, rate limiting and authentication; an orchestrator for workflows across services.

The tech stack we typically use

Pragmatic choices with strong community support and long roadmaps. We don't want tools that will no longer be maintained in two years.

Middleware platforms

n8n for low-code workflows, Mendix where your team has already chosen a low-code direction, Boomi and Workato for enterprise-scale iPaaS.

Custom middleware

NestJS or FastAPI for custom services. Spring Boot or .NET 8 where that fits your stack. Always TypeScript or statically typed languages to limit refactoring risk.

Events and messaging

Kafka, RabbitMQ, Azure Service Bus, AWS SQS+SNS. NATS for lighter setups. A schema registry (Avro, JSON Schema) for version discipline.

API gateway

Kong, AWS API Gateway, Azure API Management, Cloudflare API Shield. Rate limiting, authentication and API key management out of the box.

Observability

Datadog, Grafana+Prometheus+Loki, OpenTelemetry for tracing. Request-level logs so a post-mortem doesn't take hours.

Authentication and secrets

OAuth 2.0, OpenID Connect, mTLS where that is the standard. HashiCorp Vault, Azure Key Vault or AWS Secrets Manager for credentials — never in code.

What sets us apart on integration projects

Anyone can write an API call. The difference lies in choices that still make you happy three years from now, rather than forcing a rebuild.

Vendor-independent abstraction layers

There is always a dedicated abstraction layer between your business logic and the external API. If the supplier changes their API or you switch platforms in two years, you only rebuild the adapter, not the applications that use the data.

Idempotent endpoints and transactional semantics

A duplicate post must never create duplicate orders. For every integration, we think about idempotency keys, deduplication and transactional outbox patterns from the start, where needed.

Honest triage

Not every pain point deserves a new integration. Sometimes it's better to adjust a process, deliver a report or use a different system. We'll tell you if we think an integration adds no value.

Maintenance included from day 1

Documentation, runbooks, ADRs, monitoring dashboards and SLA baselines are delivered together with the integration. At the end of a project, you don't have a black box, but a maintainable part of your IT landscape.

Frequently asked questions about building integrations

What is the difference between an API, an integration and middleware?

An API is the interface a system offers. An integration is the working link that synchronises data between two or more systems. Middleware is an intermediate layer where logic, routing and transformation come together, which is useful as soon as you connect multiple systems or have complex transformations.

Which integrations do you build most often?

ERP integrations (Exact, AFAS, Microsoft Dynamics, SAP), e-commerce (Shopify, Magento, WooCommerce), CRM (Salesforce, HubSpot), payment (Mollie, Stripe, Adyen), shipping (Sendcloud, PostNL), document automation (PandaDoc, DocuSign), CMS (Directus, Sanity), HR (AFAS, Nmbrs) and custom EDI/SOAP for legacy partners.

What if the supplier doesn't have a modern API?

Then we work with what there is — SOAP, EDI, SFTP feeds, screen scraping in extreme cases. We shield the old-fashioned protocol behind our own REST/GraphQL layer so your modern applications can talk to it normally.

How do you guarantee the integration is robust?

Idempotency, retry with backoff, dead-letter queues, monitoring with alerts, sandbox tests and gradual rollout. We also record architecture decisions in ADRs and build runbooks for operations so your team knows what to do during incidents.

How long does a typical integration take?

A simple point-to-point integration between two existing APIs: 2-4 weeks. A more complex flow with transformation and monitoring: 6-12 weeks. A broader middleware platform with multiple integrations: 3-9 months, delivered in phases.

What does an integration cost?

Simple integrations cost €5,000-20,000. Mid-sized integrations with monitoring and transformation cost €20,000-60,000. A middleware platform with multiple systems can run to €80,000-300,000. You get a concrete estimate after the discovery, not after a 30-minute conversation.

Do you work with our vendor?

As standard. We coordinate technical sessions, align on API version changes and run joint testing where needed. We already have working relationships with the most common vendors.

Do you maintain the integration after go-live?

Yes, under an SLA. Many clients have Appfront work alongside their team remotely to resolve vendor API changes, monitor anomalies and carry out periodic maintenance, while day-to-day management stays with their own team.

Ready to get your systems properly talking to each other?

We start with an integration discovery: you get an honest picture of which integrations deserve priority, which patterns suit your scale, and what a realistic plan looks like. No sales pitch.

Edit content