Published:20/03/2025
Building a scalable TMS: extended case study
This article dives into the technical architecture, integration strategies, and key development decisions behind TMS development —offering insights for CTOs and engineering teams looking to build or optimize their own SaaS logistics platforms.
Introduction: the challenge of modern logistics platforms
Transport Management Systems (TMS) have evolved significantly over the past decade. Traditional solutions often rely on manual workflows, fragmented communication, and limited integrations, making them inefficient for modern logistics operations. Companies managing global supply chains require real-time visibility, automated workflows, and seamless API integrations to optimize their transport networks.
Our client set out to solve this challenge by providing an API-first, multi-carrier TMS that simplifies transport operations, enhances visibility, and ensures seamless communication between shippers, carriers, and logistics partners. We interviewed the client and our development team to gather key insights that served as the foundation for this post.
Architecting a modern, API-first TMS
Core requirements for a scalable system
To create a highly adaptable and scalable transport management system, the platform needed to meet the following criteria:
- Seamless third-party integrations – Logistics operations depend on multiple providers (DHL, FedEx, DB Schenker, etc.), requiring an open, standardized API framework.
- Real-time shipment tracking – Businesses need accurate shipment statuses and estimated time of arrival (ETA) predictions.
- Centralized communication – Eliminate email and phone-based transport coordination through digital workflows and automated updates.
- High-performance architecture – Handle thousands of concurrent requests while ensuring low latency.
- Data standardization – Enable structured data exchange across different logistics networks, ERPs, and warehouse management systems (WMS).
With these goals in mind, the engineering team designed a modular, API-driven architecture that enables flexibility, scalability, and automation across logistics workflows.
Micro frontends: enhancing modularity and scalability
One of the key architectural decisions in building the platform was adopting a micro frontend (MFE) architecture. Given the complexity of a multi-tenant Transport Management System (TMS) with diverse user roles—shippers, carriers, warehouse managers, and logistics coordinators—a monolithic frontend would have been difficult to scale and maintain. Instead, we implemented micro frontends to enhance modularity, improve developer efficiency, and accelerate feature delivery.
How micro frontends were Implemented in the project
The platform frontend is built using React.js, but instead of a single monolithic application, we divided the UI into independent, self-contained micro frontends. Each micro frontend is responsible for a specific domain within the TMS and operates independently while seamlessly integrating into the main platform.
- Shipment Management UI: Handles booking, tracking, and shipment status updates.
- Carrier Dashboard: Provides transport providers with real-time shipment data and performance analytics.
- Warehouse and Dock Scheduling: Manages inbound/outbound logistics and appointment scheduling.
- Admin and Configuration Panel: Allows businesses to set permissions, configure integrations, and customize workflows.
- Invoicing Module: Manages the generation and tracking of invoices, ensuring seamless financial processes.
Each micro frontend is deployed separately and loaded dynamically when needed. We used Webpack Module Federation to enable this, allowing different micro frontends to be developed and deployed independently while still behaving as a single cohesive platform for the end user.
Tech stack and key development decisions
1. Backend architecture: Nest.js & GraphQL for scalable API
The platform’s backend is built with Nest.js, a framework leveraging TypeScript and Node.js, providing modular design, dependency injection, and easy scalability.
To optimize API performance and reduce bandwidth consumption, the platform uses GraphQL instead of REST. The benefits of GraphQL in a TMS include:
- Efficient Data Retrieval: Fetch only the required fields instead of over-fetching large JSON responses.
- Flexible Queries: Allow clients (ERPs, logistics providers) to request data specific to their operations.
- Reduced API Calls: Consolidate multiple REST API calls into a single GraphQL query.
2. Real-time shipment tracking with WebSockets & Redis
One of the biggest challenges in logistics is delays and unexpected disruptions. To provide real-time shipment visibility, the platform integrates with external tracking services (Project44, Aftership, Shippeo) and uses WebSockets for real-time status updates.
This architecture significantly reduces lag in shipment updates, ensuring logistics managers have accurate, real-time ETAs for decision-making.
- WebSockets enable instant event-driven updates on shipment progress.
- Redis is used for real-time event caching, ensuring that users receive immediate notifications without polling APIs.
- Webhooks for integration with your service
3. Electronic Data Interchange (EDI) for seamless carrier integration
Many logistics providers still rely on EDI-based communication to exchange transport orders, invoices, and status updates. To ensure compatibility with major logistics networks, the platform implemented:
- EDIFACT and INOVERT protocols to standardize data exchange.
- IFTMIN (DISPOR) messages for automated transport bookings with carriers.
- IFTSTA (REPORT) messages for shipment tracking updates.
By implementing OpenAS2, the platform enables secure, automated document exchange, reducing the reliance on email-based transport coordination.
4. API gateway and authentication strategy
To support scalability, security, and multi-tenancy, the platform employs:
- API Gateway: Manages authentication, request routing, and rate limiting (10 requests per second per account).
- JWT-based Authentication: Ensures secure API access with token expiration and refresh mechanisms.
- Role-Based Access Control (RBAC): Defines user roles (shippers, carriers, warehouse managers) to enforce data privacy.
This architecture enables seamless integration with ERP systems like SAP TM and Reflex WMS, ensuring secure and controlled access to transport data.
Optimizing TMS performance for large-scale logistics operations
1. Handling high API traffic efficiently
With 3,000+ businesses and 15,000+ carriers using the platform, the system must handle a high volume of requests. To ensure optimal performance:
- Load balancing with Nginx & Kubernetes – Distributes API requests efficiently across multiple instances.
- Caching strategies with Redis – Reduces database load by caching frequently requested transport data.
- Message queues (RabbitMQ) – Asynchronous processing of background tasks like document generation and bulk data imports.
2. Predictive ETA calculation with AI and external data sources
The platform enhances delivery predictability by integrating real-time traffic, weather, and carrier data into its ETA models.
- Data sources: P44, Aftership, Google Traffic APIs.
- Processing pipeline: Machine learning models predict delays based on route history and external conditions.
- Real-time updates: Redis-backed messaging ensures instant notifications on ETA changes.
This approach reduces delivery uncertainty and enables proactive logistics planning.
Pre-built integrations for rapid onboarding
To accelerate customer adoption, the platform provides pre-built integrations with logistics and supply chain platforms, including:
- Global Carriers: DHL, FedEx, DB Schenker, Kuehne+Nagel.
- Supply Chain Systems: SAP TM, Reflex WMS, Aftership.
These plug-and-play integrations allow businesses to onboard quickly without extensive development, reducing time-to-value.
Results: transforming logistics operations through technology
Since its launch, the platform has revolutionized transport management by:
- Connecting 3,000+ companies to a single, centralized logistics platform.
- Processing 340,000+ shipments per year, reducing operational inefficiencies.
- Managing 15,000+ active carriers, ensuring a seamless transport network.
Client testimonial
I've worked closely with Twelvedevs from the start of product development. The team consistently goes above and beyond to ensure that every aspect of the project aligns with our technical expectations. Their depth of knowledge, especially in software architecture and integration capabilities, has been invaluable. Not only do they meet deadlines, but they also proactively offer innovative solutions to optimize performance. Their work has enabled us to scale quickly and maintain a high level of operational efficiency.
CTO
Key takeaways for teams developing SaaS solutions for logistics
- GraphQL and WebSockets improve efficiency, while an API gateway ensures security and scalability.
- EDI implementation (EDIFACT, IFTSTA, IFTMIN) ensures compatibility with legacy logistics systems.
- Use Redis, AI-driven ETA models, and external data sources to enhance shipment visibility.
- Use Kubernetes, load balancing, and caching to handle large-scale logistics operations.
- Reduce customer onboarding friction by offering off-the-shelf integrations.
Conclusion: building the future of logistics SaaS
Our client's success demonstrates that a well-architected, API-driven TMS can revolutionize logistics management. By leveraging modern backend frameworks, real-time tracking, and scalable infrastructure, developers can create high-performing logistics platforms that meet the growing demands of global supply chains.
For CTOs and engineering teams building a logistics SaaS product, investing in scalable architectures, APIs, real-time visibility, and seamless integrations will be the key to long-term success.
Build a scalable, future-proof logistics SaaS with Twelvedevs
Our SaaS development expertise proves a well-architected, API-driven, and modular logistics platform can transform supply chain operations. Whether you're building a TMS, WMS, or freight management platform, adopting micro frontends, real-time tracking, and API-first development is key to scalability and efficiency.
Twelvedevs specializes in building high-performance, integration-ready platforms tailored for the logistics operations. Let’s build the future of logistics together!
