Dynamic SMS Dispatching Platform (Configurable Multi-Provider Messaging System)

Designed and implemented a highly configurable, enterprise-grade SMS dispatching platform capable of dynamically routing messages through multiple SMS providers using rule-based configuration and runtime provider selection. The system was built to support high-volume transactional messaging, multi-system integrations, and real-time delivery tracking while ensuring reliability, scalability, and maintainability in distributed environments. The primary goal of the project was to build a centralized SMS orchestration service that can be integrated with multiple business applications while allowing dynamic provider switching without requiring code changes. The platform supports both HTTP and SMPP based providers, enabling seamless integration with telecom operators, SMS aggregators, and third-party messaging gateways. The service was developed using Java, Spring Boot, PostgreSQL, RabbitMQ, and REST APIs, following clean architecture principles and modular design to ensure long-term extensibility and maintainability. The system is capable of handling high message throughput with retry mechanisms, automatic fallback routing, and idempotent processing to prevent duplicate message delivery. A database-driven configuration model was introduced to allow runtime management of providers, routing rules, credentials, and failover priorities. Each SMS request is processed through a routing engine that determines the most suitable provider based on predefined conditions such as country code, provider priority, message type, and provider availability. If a provider fails, the system automatically retries using the next configured provider without manual intervention. To support high performance, asynchronous processing was implemented using message queues. Incoming requests are accepted via REST API, stored in the database, and pushed to a queue for background processing. Worker services consume the queue and send messages to the selected provider, allowing non-blocking request handling and better performance under heavy load. This architecture improves fault tolerance and allows horizontal scaling when traffic increases. For SMPP integrations, persistent session management was implemented to maintain stable connections with telecom gateways. The system supports automatic reconnection, session monitoring, delivery receipt parsing, and message correlation using provider message identifiers. Special handling was added to support scenarios where delivery receipts arrive before the submit response, ensuring correct status mapping even in out-of-order situations. Delivery tracking was designed using an event-driven approach where each provider callback or delivery receipt is first stored in a callback inbox table before being matched with the corresponding SMS attempt. This prevents data loss and ensures accurate status updates even when providers send duplicate, delayed, or unordered notifications. A reconciliation process was implemented to handle unmatched callbacks and maintain consistency between request records and provider responses. To ensure high reliability, idempotency control was applied at multiple levels to prevent duplicate processing. Each request is assigned a unique identifier, and repeated submissions are safely ignored or merged based on configuration. This is especially important in distributed systems where network retries or client timeouts may cause the same request to be sent multiple times. A web-based administration module was developed to allow runtime management of providers, routing rules, credentials, and system parameters. Administrators can enable or disable providers, change routing priority, test provider connectivity, and monitor message status without restarting the service. This reduces operational overhead and allows quick adjustments in production environments. The platform was designed for containerized deployment and supports cloud, on-premise, and hybrid environments. Docker images, CI/CD pipelines, and automated deployment scripts were used to ensure consistent builds and reliable releases. Health checks, graceful shutdown handling, and connection lifecycle management were implemented to support orchestration platforms such as Kubernetes and AWS ECS. Performance optimization was applied to database access, queue processing, and provider communication to ensure the system can handle large message volumes without degradation. Indexing strategies, batch processing, and connection pooling were used to reduce latency and improve throughput. The final solution provides a flexible and production-ready messaging platform suitable for financial systems, OTP delivery, notification services, and enterprise integrations where reliability and dynamic routing are critical. The architecture allows new providers to be added with minimal effort, making the system future-proof and adaptable to changing business requirements.