Modernizing a Financial App with Azure and AI: A Post-AI-Reflection

After passing the Azure AI Fundamentals (AI-900) exam, I found myself contemplating how to apply these concepts to real-world scenarios. Specifically, I considered how to modernize a legacy financial reconciliation app using Azure services. This exercise also serves as preparation for my upcoming Azure Solutions Architect certification (AZ-305).

Understanding the Legacy System

The application in question is a typical back-office system:

• Frontend: Angular
• Backend: .NET microservices
• Batch Processing: A Windows Service handling end-of-quarter jobs

Its primary functions include:

• Ingesting financial transactions
• Matching records and flagging discrepancies
• Generating reports for finance teams

Modernizing the Frontend and APIs

To enhance scalability and maintainability:

• Azure Static Web Apps can host the Angular frontend.
• Azure Kubernetes Service (AKS) or Azure Container Apps can manage the .NET micro-services.
• Azure Load Balancer ensures efficient traffic distribution across services.

This setup allows for independent scaling and streamlined deployments across the frontend and backend.

We can use Azure Static Web Apps to host the frontend because it’s built with just HTML, CSS, and JavaScript there’s no server-side rendering or dynamic backend logic involved. These services are optimized for exactly that kind of frontend delivery and provide global availability, SSL, and CI/CD support out of the box.

For our .NET micro-services, we have two deployment options depending on the level of control and complexity we need:

• If we want full control over networking, scaling policies, and container orchestration, we can use Azure Kubernetes Service (AKS). This gives us the flexibility to configure ingress/egress, pod scaling, and more advanced Kubernetes features.
• If we prefer a more fully managed, serverless-like approach with simplified scaling and networking, we can use Azure Container Apps. This is ideal when we want less operational overhead.

Regardless of which approach we choose Azure Static Web Apps, AKS, or Container Apps we’ll use Azure Load Balancer to distribute incoming traffic across service instances. This also sets us up to scale across multiple availability zones, ensuring high availability and fault tolerance.

Handling Legacy Batch Jobs

Recognizing the value in existing systems:

• Azure Virtual Machines (VMs) can host the Windows Service without requiring a complete rewrite.
• Availability Sets and VM Scale Sets provide resilience and scalability.
• Azure Queue can manage job distribution.

This approach modernizes the batch processing component while preserving its core functionality.

By placing VMs in an Availability Set, Azure ensures the VMs are distributed across different physical racks within the same availability zone. This provides protection from hardware failures, power outages, and scheduled maintenance ensuring that at least one VM remains available.

Using a VM Scale Set, we can create and deploy identical VMs from a custom image, making it easy to scale batch processing as demand increases. We can define rules such as “scale out if CPU usage exceeds 70%,” and Azure will automatically add more VM instances to handle the load.

By moving to Azure Queue, we gain better control over how jobs are distributed to the batch processing service. This improves reliability, decouples job production from job processing, and gives us a more scalable architecture overall.

Integrating AI for Smarter Reconciliation

Inspired by the Azure AI certification, I explored incorporating AI to enhance data matching:

• Azure Machine Learning can train models on historical transaction data, considering factors like amount, vendor, date, payment method, and source.
• Azure Container Instances or AKS can host the model as a REST API.
• Azure Blob Storage serves as a repository for training data and logs.

After going through the Azure AI Fundamentals certification, I wanted to explore how AI could improve our reconciliation process particularly the matching logic that usually relies on static rules.

Instead of depending solely on if-then conditions, we can train a model using Azure Machine Learning that learns from historical transaction data. Think of it like this: we feed it past matched and unmatched transactions, along with attributes like:

• Transaction amount
• Vendor name
• Date and time
• Payment method
• Internal vs. external source

Once trained, the model can score incoming transactions based on how likely they are to match, flag anomalies, or even predict potential mismatches all with a confidence score.

We can host this model using Azure Container Instances or AKS, exposing it as a REST API. That way, our existing systems whether it’s the batch job or real-time micro-services can call the API as part of the reconciliation flow.

To support this, we use Azure Blob Storage to hold training data, logs, and model outputs. Over time, this setup reduces the number of manual reviews and increases accuracy especially as the model continues to improve with more data.

This kind of integration is a simple but powerful way to bring AI into an existing system no need for a complete rewrite, just smarter logic layered on top.

Data Storage and Management

For efficient data handling:

• Azure SQL Database stores transactional data and reports.
• Azure Blob Storage manages large files and logs.

For the data layer, we keep things simple and cloud-native using fully managed Azure services.

We use Azure SQL Database to store all structured data things like transaction records, reconciliation results, and audit logs. Since it’s a managed service, we don’t need to worry about patching, backups, or high availability Azure handles all of that.

For larger files like exports, logs, and any unstructured data, we rely on Azure Blob Storage. It’s cost-effective, scalable, and great for storing things like training data for the AI model or raw transaction files uploaded from external systems.

Using these services gives us durability, security, and the flexibility to scale as the system grows without getting bogged down by infrastructure management.

Monitoring and Cost Management

To maintain operational efficiency:

• Application Insights provides end-to-end tracing.
• Azure Monitor and Log Analytics offer infrastructure visibility.
• Azure Cost Management helps track usage and set alerts.

To keep everything observable and under control, we use a combination of Application Insights, Azure Monitor, Log Analytics, and Cost Management.

Application Insights gives us end-to-end tracing across both the Angular frontend and our .NET microservices. This helps us pinpoint where latency is coming from, track user flows, and catch errors early all without adding much overhead to our code.

Azure Monitor and Log Analytics give us a deeper view into the underlying infrastructure. We can track VM performance, container health, queue depths, and more all in one place.

And with Azure Cost Management, we can set alerts and track usage across the entire system. This is especially useful when batch workloads spike at the end of a quarter it lets us keep costs predictable and make smarter scaling decisions.

Together, these tools give us full visibility and help us stay ahead of issues before they impact users.

Final Thoughts

This exercise really helped bridge the gap between theoretical knowledge from the AI-900 certification and what it actually looks like to apply those concepts in a real-world system.

It gave me the opportunity to think holistically not just about AI, but also about architecture, infrastructure, and modernization. Designing around Azure services forced me to make trade-offs between control and simplicity, performance and cost, managed vs. self-managed.

Whether it’s:

• Running legacy batch processes on scalable infrastructure,
• Integrating AI to assist with decision-making,
• Or scaling frontend and backend services independently using containers and server-less options

This kind of hands-on exploration also helps me prepare for the AZ-305 certification, where architectural thinking and real-world use cases are front and center.

If you’re working on modernizing a legacy system, I’d love to hear your approach. What services have worked for you? How are you handling batch workloads, or layering AI into an existing process?

Feel free to reach out or share your thoughts I’m always learning, and I’m curious how others are navigating similar challenges.

Disclaimer: The views and opinions expressed on this website are solely those of the author and do not necessarily reflect the official policy or position of any employer or organization affiliated with the author.