Case Study - Enterprise ERP modernization with micro-frontend architecture

Overview

EnterpriseFlow came to us with a critical challenge: their core business operations relied on a sophisticated but aging IBM AS/400 ERP system. The monolithic architecture made it difficult to add new features, the outdated UI hindered productivity, and recruiting developers with legacy system expertise was increasingly challenging.

We proposed a transformative solution—keep the proven AS/400 database while building a modern micro-frontend ecosystem on top through a phased migration strategy. Using a ScrumBan approach allowed for quick adaptation while maintaining focus on continuous integration, clean code practices, and Test-Driven Development.

The result is a comprehensive enterprise system with six independently deployable applications orchestrated through Single-SPA, combining Angular 19 frontend modules with Spring Boot 3.4+ backend services, all connected to the legacy IBM AS/400 database through optimized connection pooling and type-safe query layers.

What we did

Technical architecture

The system consists of six micro-frontend applications:

Shell Application: The orchestration layer using Single-SPA that manages routing and module loading across the entire ecosystem.

Home Dashboard: Built with Angular 18, providing the main entry point with dynamic menus, widgets, and real-time visualizations using Chart.js.

Main ERP Application: The core business operations module with Spring Modulith architecture, handling products, purchase orders, suppliers, finance, and scheduling. Features include QueryDSL for type-safe queries, DB Scheduler for background jobs, and OpenAPI documentation.

Customer Module: Comprehensive CRM functionality managing customer relationships, addresses, contacts, and financial data with advanced PrimeNG data tables and filtering.

Teamwear Contract Management: Specialized module for contract lifecycle management with sublimation pricing, margin simulation, PDF generation in four languages using Apache FOP, and HubSpot/Synogix integrations.

Navigation Module: Shared navigation component providing consistent user experience across all applications.

Phased migration strategy

The transformation from a monolithic AS/400 system to a modern micro-frontend architecture required careful planning and execution. We implemented a phased migration approach that minimized risk while delivering continuous value:

Phase 1 - Foundation: Established the Single-SPA shell, CI/CD pipeline, and development standards. Created the first micro-frontend (Home Dashboard) as a proof of concept while maintaining the AS/400 as the single source of truth.

Phase 2 - Core modules: Migrated critical business functions—customer management and product operations—into independent Angular applications with new Spring Boot backends. Each module was thoroughly tested before production deployment.

Phase 3 - Specialized features: Developed the Teamwear Contract module with complex pricing logic and external integrations (HubSpot, Synogix), demonstrating the architecture's flexibility for specialized business needs.

Phase 4 - Continuous enhancement: Ongoing addition of features, performance optimizations, and migration of remaining AS/400 screens to the modern stack as business priorities dictate.

This incremental approach allowed the business to continue operating without disruption while progressively modernizing the technology stack.

Development methodology & practices

The project demanded exceptional discipline and proven engineering practices to deliver enterprise-scale results:

ScrumBan methodology: Combined Scrum's structured sprints with Kanban's flexibility, allowing for adaptation to changing priorities while maintaining steady progress. Regular planning sessions ensured alignment with business objectives.

Test-Driven Development: Every feature began with failing tests, ensuring code quality and preventing regressions. The comprehensive test suite (unit, integration, E2E) provided confidence to refactor and evolve the codebase continuously.

Clean code principles: Strict adherence to SOLID principles, meaningful naming, and consistent patterns. ESLint and Prettier automated style enforcement, while SonarQube tracked code quality metrics.

Continuous Integration: Jenkins pipelines ran on every commit, executing linting, tests, and builds in parallel. Failed builds blocked merges, ensuring the main branch always remained deployable.

Documentation culture: OpenAPI/Swagger for APIs, inline code documentation, and architectural decision records (ADRs) maintained comprehensive project knowledge throughout the migration.

The combination of disciplined practices and flexible methodology enabled delivery of enterprise-scale software while maintaining high quality standards.

Backend excellence

The backend infrastructure demonstrates enterprise-grade architecture:

• Spring Boot 3.4+ with Java 21 providing modern language features and performance
• Spring Modulith ensuring clear domain boundaries in the main application
• HikariCP connection pooling with 20-connection pool for optimal AS/400 performance
• QueryDSL providing compile-time SQL validation and type safety
• MapStruct for type-safe DTO mapping between layers
• DB Scheduler with web UI for distributed task scheduling
• Apache FOP for multi-language PDF generation
• Custom security framework with SSO integration and JPA audit trails

DevOps & quality

Our commitment to quality and continuous integration was fundamental to the project's success. We implemented a comprehensive CI/CD pipeline using Jenkins with parallel build strategies:

Automated quality gates:

• ESLint and Prettier enforce code style consistency
• Unit tests (Jasmine/Karma for frontend, JUnit 5 for backend) run on every commit
• Integration tests verify API contracts and database interactions
• Cypress E2E tests validate critical user workflows with VPN support
• Code coverage tracking ensures comprehensive test coverage

Test-Driven Development workflow:

• Red-Green-Refactor cycle enforced through peer review
• Tests written before implementation code
• Comprehensive test suite (800+ unit tests, 200+ integration tests, 50+ E2E suites)
• Regression prevention through automated test execution

Continuous Integration/Deployment:

• Node.js 20.11.1 for frontend builds, JDK 21 for backend builds
• Parallel build execution for faster feedback
• Automated deployment to test environments on successful builds
• Slack and email notifications provide immediate build status feedback
• Deployment to Apache Tomcat (backend) and Apache HTTP Server (frontend)

The system maintains 99.9% uptime with zero-downtime deployments, demonstrating the reliability achieved through disciplined CI/CD practices.

Results & impact

The modernization has transformed EnterpriseFlow's operations across multiple dimensions:

Phased migration success: The incremental approach eliminated the risks of a "big bang" rewrite. Business operations continued uninterrupted throughout the multi-year transformation, with new features delivered every sprint. Users adopted the new system gradually, one module at a time.

Developer productivity: The modern stack (Angular, Spring Boot, TypeScript) enables efficient development with excellent tooling and IDE support. Recruitment potential improved dramatically—Java and Angular expertise is far more available than AS/400 specialists. The TDD approach reduced debugging time and increased confidence in refactoring.

Performance: The new connection pooling (HikariCP), query optimization (QueryDSL), and modern architecture resulted in 60% faster response times for critical business operations. Users experience snappier interactions, especially in complex data operations.

Code quality: The ScrumBan methodology combined with TDD and automated quality gates ensured consistent, maintainable code throughout the migration. Clear coding standards and comprehensive CI/CD pipelines enabled rapid, confident iteration on complex features.

Scalability: The micro-frontend architecture allows new features and modules to be added without modifying the core shell. Independent deployment means features reach production faster with less risk.

Integration capabilities: RESTful APIs and modern integration patterns made it easy to connect with HubSpot CRM, Synogix ERP, and other external systems—opening new business opportunities that were difficult with the legacy system.

Future-proof architecture: The modular architecture provides a clear path to microservices if needed, while Spring Modulith ensures clean boundaries today. The system can evolve as business needs change.

Quality & reliability: 99.9% uptime, zero-downtime deployments, and a comprehensive test suite (1000+ tests) provide confidence in every release. The investment in TDD and clean code pays dividends in reduced bugs and faster feature development.

The project demonstrates that legacy modernization doesn't require a risky "big bang" rewrite. With a phased approach, agile methodology, and unwavering focus on quality through TDD and CI/CD, we transformed a 30-year-old system into a modern, maintainable platform—while keeping the business running smoothly throughout.