Navigation

Get in touch
Logo
News

Develop interfaces

Duplicate entries cost you every day.

When ERP, CRM, portals and business applications each hold a different version of the truth, errors and rework follow. We connect your systems through documented interfaces, clarify the system of record and make sure transfers stay traceable even when disruptions occur.

black flat screen computer monitor — illustrative image
From the initial task to the documented handover.

When this service helps

Develop interfaces: your brief for us.

  • Connect ERP, CRM and business applications
  • Enable partner access through APIs
  • Reduce file exports and manual double entry

We connect ERP, CRM, machines and partner applications through interfaces chosen to fit each case. This includes documented API contracts, secured access and controlled version changes. Depending on the process, direct queries, events or scheduled file transfers may be the right approach. What matters is correct data, recognizable errors and manageable operations.

What the assignment can include

  • API design as a contract using OpenAPI or GraphQL, reviewed with all consumers
  • Authentication and authorization with OAuth 2.0 and OpenID Connect via Keycloak
  • API gateway with rate limiting, key management and logging per consumer
  • Event-driven integration with Apache Kafka, retries and traceability per message
  • Contract tests and versioning with documented deprecation of old versions

We define the specific scope, acceptance points and your involvement in the proposal.

The context at a glance

Connecting data means connecting responsibility.

  1. 01

    Source

    Determine the authoritative data and responsibility

  2. 02

    Contract

    Define meaning, permissions and errors

  3. 03

    Transfer

    Handle retries and ordering

  4. 04

    Reconciliation

    Check results and resolve discrepancies

Planning, implementation and decisions

What matters for Develop interfaces.

01

Data ownership before data transport

A connection is quickly established from a technical point of view; the harder question is which system is right when data conflicts. We define systems of record, keys and business states. Required fields, time zones, units and the meaning of a deletion are agreed between the teams involved.

The interface contract contains examples and error cases, not just field names. This lets business units check whether an event actually has the intended meaning. Before the rollout, we also define how historical data is migrated and how new changes are processed separately from it.

02

Synchronous, event-based or scheduled reconciliation

A direct API query fits a response that is needed immediately. Events decouple workflows but require careful handling of order, retries and delayed messages. For some existing systems, a controlled batch import remains the more economical solution. We choose the pattern based on the process and the system’s capabilities.

For example, duplicate messages must not trigger duplicate orders. That is why we plan for unique transaction identifiers, safe retry handling and business-level reconciliation. Messages that cannot be processed need a visible error path with a clear owner instead of getting lost unnoticed.

03

Interfaces as an operable service

Access is scoped per application or partner. Permissions, rate limiting, logging and how credentials are handled are all part of the integration concept. An API gateway can bundle these rules, but it does not replace business-level checks within the application.

Versioning and deprecation periods protect connected systems from unexpected changes. Contract tests verify compatible behavior, and monitoring makes outages and backlogs visible. The handover includes example calls, points of contact and a process for handling failed transfers.

Tools follow the task

Technology that fits your environment.

  • OpenAPI
  • GraphQL
  • gRPC
  • Apache Kafka
  • Keycloak
  • Kong

The selection depends on existing systems, your team and later operations. Not every project needs all the technologies listed.

For business owners and technical teams

The decisions behind the implementation.

04

Retries, ordering and business-level reconciliation

After a timeout, an interface cannot always tell whether the other side has already processed a request. Retrying blindly can then create duplicate bookings. For write operations, we define how a unique identifier maps repeated requests to the original one and how long this information is retained. The identifier alone is not enough: processing and storing the result must fit the transaction model.

With events, we additionally consider ordering and delayed delivery. A cancellation can arrive before a downstream service has processed the original order. Permitted state transitions and version information help handle such cases correctly from a business perspective. Error queues need clear ownership and a controlled restart. A regular reconciliation of important data finds discrepancies that pure monitoring of successful HTTP responses does not detect.

05

Evolving contracts without surprising connected teams

Besides data types, an API contract also describes meaning, error cases and limits. We clarify whether a missing field, an empty value and an explicit deletion count as different operations. Monetary amounts need a currency and rounding rules, and time values need an unambiguous reference. For large data sets, pagination, filtering options and stable sorting are part of the contract. Example requests make these rules verifiable for consumers.

Even seemingly additive changes can cause problems if a client only accepts known values. That is why we keep track of consumers and check changes against their expectations. New versions get a transition path with documentation, a way to test them and a deprecation plan. For webhooks, we define origin verification and how repeated delivery is handled. A traceable integration history helps support follow a specific business transaction across several systems.

06

Containing failures and controlling partner access

A slow target system must not create an unlimited number of waiting connections in every upstream service. We plan timeouts, limited retries and capacity limits that fit the business process. Some tasks can be buffered, while others must fail with an understandable response. The fallback value for a failed service must not pretend to be current or approved information.

Access for partners and applications is granted separately and designed to be revocable. Rate limiting alone does not prevent unauthorized data access; business-level permissions are checked in addition. Logs are meant to make errors analyzable without spreading credentials or complete sensitive payload data. The handover therefore also includes credential renewal, alerting on backlogs and a procedure for reprocessing failed messages in a targeted way.

Results you can verify

What you take away.

Result 01

API contracts with documentation and example calls

Result 02

Gateway configuration with a permission concept

Result 03

Contract tests and versioning policy

Example project flow

This is what the engagement can look like.

A customer portal is meant to bring together order statuses from ERP and logistics. Unique order identifiers link the data. Delayed shipping notifications are processed retroactively; users see a clear status instead of conflicting information.

Illustrative scenario, not a customer reference or a guarantee of results.

This helps you get started

  • API documentation and test access for the systems involved
  • Example data sets with a business explanation
  • Owners for each data source and interface

Missing documents are not an obstacle. We work out together which information needs to be gathered first.

Your project in detail

Connect software without losing business rules.

We develop interfaces within your software projects and to existing business systems. The focus is on keeping a business process complete and traceable even across several applications.

Clarify business meaning before field mapping

Fields with the same name can carry different content. We align statuses, identifiers, time zones and units with the teams involved. For each data flow, we define which system holds the authoritative information and how later corrections are passed on.

An interface contract also describes errors and special cases. Missing mandatory data, unreachable targets and invalid state changes require different responses. Examples and tests make these rules verifiable before the complete business application is finished.

Account for retries, sequence and diagnostics

Network interruptions can leave it unclear whether an action has already succeeded. We use suitable transaction identifiers and reconciliation so that a retry does not unintentionally create a second order or booking. Which guarantee can be achieved depends on both systems involved.

For ongoing operation, we make cases correlatable across system boundaries. A support team should be able to see where processing stands, without storing confidential payload data in full in the logs. Contract changes are versioned in coordination with the teams involved and tested against known consumers.

Illustrative project scenario

How the service helps in everyday use.

Example: A new application creates orders in the ERP system. After a timeout, it uses a unique reference to check whether the order already exists. The user receives a clear status, instead of accidentally triggering further orders by clicking again.

This example explains a possible process and is not a customer reference.

Before you place an order

Your questions about Develop interfaces.

Can you connect systems without a modern API?

Depending on the system, file import, adapters or approved database access are possible. We check vendor approvals, change risks and later maintenance in the process. Direct access to internal data structures can be fragile and is not treated as an equivalent substitute for a stable API.

How are duplicate or failed transfers handled?

We plan transaction identifiers, controlled retries and business-level data reconciliation. Cases that cannot be resolved automatically go into a visible error process. Which retry is safe depends on the business case: reading data and triggering a payment need different rules.

Is real time always necessary?

No. What matters is how current information needs to be for the workflow. A scheduled reconciliation can be sufficient and simpler to operate. For time-critical decisions, latency, failure behavior and data consistency are explicitly agreed.

The next step

Tell us where things are stuck today.

A short description of your application, the problem and your goal is enough to get started. The selected service is carried over into your contact request.

Request this service

Our Partners

  • Microsoft
  • Microsoft Azure
  • Amazon AWS
  • Google Cloud
  • Thales Group
  • Arrow ECS
  • Vodafone
  • IBM
  • Veeam
  • Atlassian
  • JetBrains
  • NinjaOne
  • OPSWAT
  • Utimaco
  • Eviden

Accessibility

Adjust the display to suit your needs.

A simple version is not available for this page yet.

Settings currently apply to this visit. Allow saving in Cookie settings to remember them.