Legacy Wealth Management Platform Modernization with Rule-Based Portfolio Engine

Challenge

The client’s portfolio management platform was a monolithic WPF desktop application built on the .NET Framework. Portfolio allocation logic and validation rules were embedded directly in the client application — tightly coupled, difficult to scale, and impossible to govern centrally.

Three compounding problems drove the need for re-architecture:

1. Static Templates, Manual Overrides

Portfolio construction relied on model templates stored in SQL Server. Advisors manually adjusted allocations or performed external calculations to adapt strategies to specific client mandates. This slowed proposal generation and introduced inconsistencies across client portfolios.

2. KYC Data Not Usable by the Portfolio System

KYC and client risk profiling outputs were digital, but not structured in a way the portfolio system could interpret. Relationship managers translated risk scores and investment preferences into portfolio constraints by hand — adding friction and introducing potential for error at every proposal.

3. No Systematic Audit Trail

Portfolio decisions were not logged. Audit preparation and compliance reviews required manual reconstruction from scattered records, making governance time-consuming and unreliable.

The client needed a scalable architecture that could dynamically generate personalized portfolios, with governance and compliance controls built into the platform.

Solution We Delivered

We modernized the platform by extracting the portfolio construction logic from the legacy desktop application into a single, governed backend service built on .NET 6/ASP.NET Core. The existing WPF client remained in place — its functionality unchanged — while all critical decision logic moved to the cloud.

Modular Backend with Onion Architecture

The new service is structured using Onion Architecture, separating the solution into four distinct layers:

Domain layer — portfolio rules, allocation logic, and investment constraints.
Application layer — portfolio generation workflows and validation.
Infrastructure layer — persistence, integrations, and messaging.
API layer — REST endpoints consumed by the existing desktop client.

This separation made the platform’s core logic independently testable, maintainable, and extensible — without requiring any changes to the user interface.

Rule-Based Portfolio Engine

KYC and suitability outputs are transformed into machine-readable constraint models and passed into the portfolio domain as structured inputs. A rule-based engine in the domain layer evaluates risk limits, investment preferences, and mandate restrictions to dynamically generate compliant portfolio allocations — thereby replacing static templates and manual overrides entirely.

Data, Messaging, and Audit

Portfolio data, rule execution results, and audit records are persisted in Amazon RDS for SQL Server. Amazon SQS and EventBridge handle asynchronous events — recalculation triggers and audit notifications — keeping the architecture simple and aligned with the client’s existing operating model. The design deliberately avoided unnecessary complexity: messaging is used only where asynchronous processing adds clear value.

Cloud Infrastructure and Observability

The service runs on Amazon ECS with Fargate, containerized using Docker. GitHub Actions and AWS CodePipeline manage CI/CD. Amazon CloudWatch and AWS X-Ray provide observability across the deployed environment, giving the operations team visibility into performance and reliability from day one.

Client’s Results

The re-architecture gave the client a governable portfolio platform with built-in compliance controls. Key outcomes across the workflow:

Faster Portfolio Proposals

Portfolios are generated dynamically against real client constraints, without static templates or manual overrides.

KYC Data Directly in the Investment Workflow

Risk and suitability outputs feed directly into portfolio construction as structured inputs, removing the manual translation step entirely.

Consistent Allocations Across Mandates

Portfolio logic runs in a single centralized service, eliminating inconsistencies caused by rules applied differently across desktop clients.

Audit-Ready Governance

Rule execution results and allocation decisions are recorded systematically, so compliance reviews draw on structured records rather than reconstructed history.

Foundation for Future Expansion

New mandate types, product categories, or governance rules can be added to the backend service without touching the desktop interface.