60+ carriers, 30+ countries, $10M+ a year in optimized shipping costs for a global TMS

Client story

Carrier integration is one of the most important business tasks for supply chain companies. Erbis helped our client, a global transportation management system (TMS), integrate with a large set of carriers: DHL, FedEx, USPS, DPD, UPS, C.H. Robinson, Flexport, Shippo, Omni Logistics, DSV, World Courier, ABF Freight System, Crane Worldwide, and many other global and local companies such as Czech Post and Blue Dart.

The engagement in numbers:

• 60+ carrier APIs integrated and maintained
• 30+ countries covered
• $10M+ in optimized costs per year for the client and its customers
• 8 Erbis experts: software engineers, a business analyst, a project manager and a QA engineer

Challenge

Integrating with a single carrier is straightforward. The complexity multiplies when you integrate with 10, 50 or 100.

• Diversity. Integration standards vary (EDI, REST, SOAP, XML), and carriers’ IT infrastructure varies with their investment levels and history of technology adoption. Carriers also have different data models, shipment lifecycles and services, so a one-size-fits-all approach is impossible.
• Different levels of technology adoption. Some carriers are only adopting REST in 2024. Many still have no web API and rely on older standards such as EDI, which requires different integration approaches and complicates synchronous and asynchronous processing.
• Lack of standardization and documentation. Non-standard data models and APIs, combined with thin documentation, add research and troubleshooting effort.
• Continuous API updates. Carriers upgrade their APIs, which brings unannounced changes, credential updates and the need to support multiple API versions for different customers.
• Non-technical challenges. Varying international regulations and security concerns require legal and operational consideration.

Solution

To simplify development and assure quality, we applied several approaches:

• Asynchronous flows. Regardless of the communication protocol (EDI, SOAP and others), asynchronous processing ensures the data is eventually collected, which reduces risk and absorbs protocol diversity.
• Data model conversion. We convert the system’s data model into each carrier’s API request and convert the response back, with error handling at both ends. This simplifies interaction with external endpoints, although slow responses and high load still have to be handled in practice.
• Handling high loads and API limitations. Managing many shipments in real time can drive high system load and hit carrier API rate limits, so the system is designed to manage load and handle rate limits gracefully through queueing and load balancing.
• Security and international regulations. Successful integration requires a thorough understanding of legal and security requirements. We follow the Governance, Risk Management and Compliance (GRC) framework to operate within legal and regulatory boundaries and manage risk.

Beyond the core integration layer, we also delivered:

• Testing environments. For carriers that do not provide their own, we build test environments. This prevents defects in the most sensitive areas (costs, permission-related functionality and others). Our engineers and the support team test each integration before it becomes available to the client’s customers.
• Automatic bids. Bidding used to be manual: users set transportation bids and carriers applied by hand. Some carriers now have rules for automatically accepting or rejecting bids, and the platform supports this automation and shows the auto-bid status instantly.
• Near-real-time shipment status. Asynchronous background jobs check the shipment status returned by the carrier, so the status shown to the user is never more than one minute behind.
• Carrier error interpretation. When a user enters incorrect data or leaves fields blank, the carrier returns an error, usually in an unreadable format. The system interprets the error and translates it into plain language so the user can correct it quickly.
• Order management. Some carriers take an order and split it into separate shipping items. The platform supports this: a customer sends an order to the carrier through the interface, the carrier creates the shipping items and returns them, and the order status updates automatically once shipping completes.

Architecture and tech stack

The TMS core runs on Java EE 7 on WildFly with an Oracle database, hosted on AWS, with an AngularJS front end. Carrier connectivity is built as microservices: per-carrier adapters for EDI, SOAP and REST translate between the canonical shipment model and each carrier’s format, and asynchronous background jobs handle status polling and bid updates.

• Java EE 7
• WildFly
• Oracle Database
• AWS
• AngularJS
• Microservices
• EDI, SOAP and REST adapters

Results

Integrating this many carriers let the client offer its customers a competitive solution with better efficiency, flexibility and visibility in logistics operations, plus the tools to optimize shipping strategy and reduce costs significantly.

The approach integrates with any shipping carrier regardless of its data exchange protocol and data type. Customers choose from the available carriers and manage them from the platform.

If a carrier is not yet supported, customers can request an integration, which takes 1 to 3 months depending on the technical particulars on the carrier’s side. Fortune 500 companies actively use the platform to move goods worldwide.

What multi-carrier integration delivers:

• Rate management and cost optimization
• Reliable customer service and user experience
• Data-driven analytics and decision-making
• Real-time shipment booking and tracking
• Higher efficiency
• Efficient documentation and compliance
• Data security

What made it work

Erbis’s takeaways from this engagement:

• Normalize once, adapt many times. A canonical shipment model with per-carrier adapters is what keeps the sixty-first integration as cheap as the tenth.
• Assume every external call can fail or stall. Asynchronous flows, queues and background status polling turned unreliable carrier endpoints into a predictable user experience.
• Build the sandbox the carrier did not. Owning test environments for carriers without one protected the cost and permission logic that customers care about most.
• Translate errors for humans. Turning raw carrier errors into plain-language guidance removed a support burden that no amount of backend robustness would have fixed.