The client is a communications-workflow company that develops software for enhancing business communications. Their portfolio spans communications-workflow solutions, fax-server technology, business process management, forms OCR processing, and database management systems - products that integrate into a single communications framework through their proprietary communications-workflow server.
The client’s proprietary communications-workflow server routes messages and attached documents between a network of application connectors. These connectors are built on the client’s proprietary connector framework and provide a wide range of functionality. The entire solution had been developed in .NET on a monolithic architecture and as the product grew, that architecture made it increasingly difficult to build new features, maintain the existing software, and scale to demand.
After a technical evaluation, we recommended migrating to a high-performance microservices architecture and porting the software from legacy .NET to .NET Core.
-Design a microservices architecture delivering high performance, scalability, and availability for the workflow server application.
-Migrate the existing application from legacy .NET to .NET Core.
-Migrate the existing gateway-module web service to the new architecture.
-Sustain an expected load of 100 requests/sec at a 1.5s response time.
-Support a maximum load of 200 requests/sec (response-time limit not defined).
We re-architected the workflow server as a set of independently deployable services, tuned for performance and built on a modern cloud-native stack:
-Microservices and APIs developed using .NET Core.
-Kubernetes used to manage Docker containers.
-Each service owns its own storage engine, keeping services independent.
-Each service exposes a REST API, consumed by API-gateway users and by other services.
-Inter-service communication via the RabbitMQ AMQP message broker, implemented as part of performance tuning.
-Distributed cache using Redis, implemented as part of performance tuning.
-In-memory cache implemented for query functions.
-DevOps integration implemented using Jenkins.
We assessed the monolithic .NET application, identified scaling and maintainability constraints, and designed a high-performance microservices architecture targeting the defined load and response-time goals.
We ported the software to .NET Core, decomposing the monolith into independently deployable services — each with its own storage and REST API — and migrated the gateway-module web service into the new architecture.
We introduced RabbitMQ for inter-service messaging, Redis distributed caching, and in-memory query caching to meet throughput and latency targets.
We containerized services with Docker, orchestrated them on Kubernetes, automated delivery with Jenkins, and validated performance and functionality across services.
A monolith that once accelerated a product can eventually become the thing holding it back - every new feature harder to add, every release riskier, every scale-up more expensive. By migrating to a microservices architecture on .NET Core, the client traded those constraints for independence: services that scale on demand, release on their own cadence, and evolve without destabilising the whole. The result is not just a faster, cheaper-to-run platform, but one built to keep growing with the business.
Focaloid helps ISVs and product companies modernize legacy applications into high-performance, cloud-native microservices from technical evaluation and architecture design through migration, performance tuning, DevOps, and QA. Whether it’s a .NET Core port, a microservices re-architecture, or a scale challenge you’ve outgrown, we can help you move forward with confidence.