- Client: A provincial government agency responsible for commercial vehicle safety and regulatory enforcement
- Industry: Government Transportation and Regulatory Compliance
- Services: Legacy Application Modernization, Cloud-Native Architecture and DevOps, Application Security, Custom Software Development
- Outcome: Modernized multiple legacy .NET and React applications into a secure, containerized cloud-native platform, cutting Windows Server licensing costs by 60% and moving release cadence from quarterly to weekly with 95% faster deployments.
Government agencies that run regulatory and enforcement systems on aging .NET Framework applications face a specific kind of risk. The systems are too critical to pause for a rewrite, too expensive to keep licensing at legacy rates, and too slow to release from to keep pace with changing business needs. Add older React front ends, manual content workflows that depend on developer time, and a team still new to Agile delivery, and modernization becomes as much an organizational challenge as a technical one.
In this legacy .NET and React modernization case study, Keyhole Software embedded a senior full-stack developer as software architect and technical lead within a hybrid vendor-government Scrum team supporting a provincial agency’s commercial vehicle safety and enforcement programs. The suite of applications included safety compliance scoring, roadside inspection workflows for field enforcement staff, and carrier profile reporting, several of them replacing aging legacy systems slated for retirement.
Legacy .NET and React Modernization at a Glance
- Rebuilt legacy .NET Framework 4.6.1 applications on .NET 8 and upgraded front ends to React 18.2 with Vite.
- Delivered a React Native (Expo) mobile application to extend roadside inspection workflows to field enforcement staff.
- Moved deployments to OpenShift and Kubernetes using GitOps pipelines built with ArgoCD and GitHub Actions.
- Reduced Windows Server licensing costs by 60% and achieved 95% faster deployments.
- Integrated Salesforce and Shopify so business users could manage content without developer involvement, cutting developers’ involvement in routine content updates by roughly 80%.
- Worked as the sole senior full-stack developer embedded in a hybrid vendor-government Scrum team, helping move release cadence from quarterly to weekly.
The Challenge
The agency’s core systems had grown up on .NET Framework 4.6.1 and earlier versions of React. Both had served the agency well for years, but the platforms were reaching the point where continuing to build on them meant carrying forward outdated tooling, slower load times, and rising Windows Server licensing costs tied to the existing infrastructure. Several of the applications in the suite were also candidates for retiring older legacy systems entirely once their modern replacements reached production.
Release cycles were quarterly, which made it difficult to respond to changing regulatory or operational needs. Routine content changes, the kind business users should be able to handle themselves, required a developer to make the change and ship a release. Security practices had not kept pace with modern scanning and secrets-management standards, and while Scrum ceremonies were already part of the team’s process, the group had not yet worked in a GitOps-driven delivery model capable of turning that cadence into weekly releases.
The mandate was to modernize the .NET and React applications onto a secure, cloud-native platform, reduce the operational and licensing cost of running them, shorten the path from code change to production, and build the team’s capacity to sustain that pace after the engagement matured.
The Approach
Phase 1: Architecture and Cloud Platform Foundation
The first phase focused on the target platform rather than the code. Keyhole architected the solution across Azure and AWS, using AWS Cognito for authentication and S3 and Lambda for automation, with OpenShift and Kubernetes as the container runtime for deployed workloads. Establishing this foundation first meant later application changes had a stable, containerized target to land on instead of being modernized twice.
Phase 2: Backend and Frontend Modernization
With the platform defined, the team rebuilt the legacy .NET Framework 4.6.1 applications on .NET 8, addressing both performance and long-term maintainability. React front ends were upgraded to React 18.2 and rebuilt on Vite, replacing older build tooling with a faster development and load experience. PostgreSQL was used for data models where a scalable, resilient relational store was the better fit.
Phase 3: Mobile Delivery with React Native
Field-facing enforcement workflows needed a cross-platform mobile option. Keyhole used React Native with Expo to deliver that functionality from a shared codebase, rather than maintaining separate native applications.
Phase 4: GitOps Pipelines and Security Hardening
To move off quarterly releases, the team implemented GitOps pipelines with ArgoCD and GitHub Actions, enabling automated CI/CD and feature-flag-driven releases so work could ship independently of a fixed release train. Alongside the pipeline work, the team strengthened platform security with HashiCorp Vault for secrets management, CodeQL and OWASP scanning in the pipeline, and Sysdig for runtime monitoring.
Phase 5: Business System Integration
Salesforce and Shopify were integrated as the systems of record and content layer respectively, giving business users direct control over content and workflow changes that previously required a developer to implement and deploy.
Phase 6: Working Within the Hybrid Scrum Team
Technical modernization only holds if the team operating the new platform can sustain it. As the sole senior full-stack developer on a hybrid vendor-government Scrum team, the Keyhole consultant worked alongside government product owners, analysts, and QA staff, sharing knowledge of .NET 8, modern React patterns, and cloud-native architecture as the platform came online. Miro and Figma supported collaborative process mapping, while JIRA and Confluence tracked delivery and documentation across the team.
Technologies Used
- .NET 8 and .NET Framework 4.6.1
- React 18.2 with Vite
- React Native (Expo)
- PostgreSQL
- Azure
- AWS Cognito, S3, and Lambda
- OpenShift and Kubernetes
- ArgoCD and GitHub Actions for GitOps CI/CD
- HashiCorp Vault
- CodeQL and OWASP scanning
- Sysdig
- RabbitMQ
- Salesforce and Shopify
- SVN and GitHub
- JIRA and Confluence
- Miro and Figma
- Kibana
Legacy System Risks Uncovered During the .NET and React Modernization
Moving the .NET Framework 4.6.1 applications toward .NET 8 surfaced coupling between the legacy code and the infrastructure it had been written against, which had to be addressed before containerization on OpenShift could proceed cleanly. Addressing this early kept the platform migration from stalling once workloads were already moved.
Security scanning with CodeQL and OWASP tooling identified gaps that had not been visible under the previous release process, where quarterly cycles left less room for continuous review. Introducing HashiCorp Vault and pipeline-integrated scanning closed those gaps as part of the delivery process rather than as a separate remediation effort.
On the process side, having Scrum ceremonies defined on paper was not the same as having a delivery pipeline that could support them. Without GitOps automation and a single senior developer pushing that shift, the platform investment risked reverting to the old quarterly cadence once the initial modernization work was complete.
Lessons from the .NET and React Modernization Project
Platform Architecture Should Precede Application Rework
Defining the target cloud and container architecture before modernizing the .NET and React applications meant the team built once against a stable target instead of modernizing the code and then re-platforming it separately.
GitOps Pays Off When Release Cadence Is the Bottleneck
Automated, feature-flag-driven pipelines with ArgoCD and GitHub Actions were what actually made a weekly release cadence sustainable, rather than a one-time push to ship faster.
Business-Managed Content Reduces Developer Bottlenecks
Integrating Salesforce and Shopify so business users could manage their own content removed a recurring source of developer interruptions and shortened the path from a business request to a live change.
One Embedded Senior Developer Can Shift a Team’s Cadence
The team already had Scrum ceremonies in place. What it needed was a senior technical resource who could pair that structure with GitOps automation and modern engineering practice. A single embedded senior full-stack developer, working closely with the existing product and business team, was enough to move the group from quarterly to weekly releases.
Results
The modernization effort reduced Windows Server licensing costs by 60% and cut deployment time by 95%, while moving the agency’s release cadence from quarterly to weekly.
Feature delivery cycles shortened from roughly three weeks to five days, and overall operational efficiency improved by approximately 30%. Developer onboarding time dropped by about 75% as the platform and documentation matured, and business-managed integrations with Salesforce and Shopify eliminated roughly 80% of developer involvement in routine content updates.
Beyond the numbers, the agency ended the engagement with a containerized, GitOps-managed platform, stronger security scanning built into the pipeline, and a team capable of sustaining a weekly release cadence on its own.
| Metric | Before | Figure | Note |
|---|---|---|---|
| Release cadence | Quarterly | Weekly | Enabled by GitOps pipelines with ArgoCD and GitHub Actions |
| Deployment speed | Baseline | ~95% faster | Compared to the prior deployment process |
| Feature delivery cycle | ~3 weeks | ~5 days | Approximate, reported by the engagement |
| Windows Server licensing cost | Baseline | ~60% reduction | From containerization on OpenShift and Kubernetes |
| Developer involvement in content updates | Baseline | ~80% reduction | After business-managed integrations with Salesforce and Shopify |
| Operational efficiency | Baseline | ~30% improvement | Reported across the modernized platform |
| Developer onboarding time | Baseline | ~75% reduction | As platform documentation and tooling matured |
Key Takeaways from This .NET and React Modernization Project
Modernizing legacy .NET and React applications for a regulatory or enforcement agency is not just a code migration. It requires defining the target cloud architecture first, building GitOps pipelines that make frequent releases sustainable, moving routine content decisions to the business users who own them, and coaching the delivery team so the new cadence holds after the project ends.
Agencies weighing a similar modernization should treat licensing cost, deployment speed, and release cadence as connected outcomes of the same architectural decisions, not as separate line items to optimize individually.
Considering a legacy .NET or React modernization for a government or regulated system? Explore Keyhole’s legacy application modernization services, cloud-native architecture and DevOps capabilities, and application security services, or contact Keyhole to discuss assessing your current platform and building an executable modernization plan.
