Introduction

The Challenge

The customer operates in the highly competitive energy trading sector, where speed, reliability, and control directly impact business outcomes. Over time, their technical foundation had become a bottleneck.

Releasing new algorithms and features required manual steps. Configuration changes were often undocumented and difficult to trace. Rolling back a failed change or testing new logic in parallel environments was complex and risky. As a result, teams moved cautiously, slowing innovation.

Onboarding new engineers was challenging. Understanding how systems worked depended heavily on tribal knowledge and outdated documentation. New hires needed significant time before they could contribute safely, increasing dependency on a small group of experienced operators.

The organisation needed a way to move faster without increasing operational risk. They required predictable deployments, clear version control, safe rollback mechanisms, and environments that allowed parallel testing, all while maintaining the reliability expected in energy trading systems.

The Solution

The transformation was delivered in phases to help the teams gradually adopt DevOps practices while modernising their tooling.

Git-First Development

All codebases were consolidated in a central Git system. Branching, pull requests, and code reviews became standard practice. This eliminated configuration drift, enabled proper change control, and provided a reliable history of all modifications.

Containerisation with Docker

Legacy applications were containerised, replacing manual VM setup with reproducible images. Build pipelines were introduced to ensure consistent, repeatable releases.

Kubernetes on Azure (AKS)

AKS became the foundation for running the modernised workloads. The adoption of Kubernetes allowed:

• unified deployment standards
• auto-scaling
• environment parity across dev, test, and production
• simplified runtime upgrades

GitOps with ArgoCD

ArgoCD replaced manual deployments with a fully automated GitOps process. Cluster state is now derived from versioned manifests, ensuring predictability and traceability:

• every change flows through Git
• upgrades are atomic and reversible
• multi-environment management is straightforward

Secret Management

Environment variables and sensitive data were migrated out of Confluence and into a secure, auditable system using Azure Key Vault (or HashiCorp Vault, depending on the service). Access control, rotation, and encryption are now handled centrally.

Monitoring and Alerting

A full monitoring stack was introduced, using Azure Monitor and Prometheus/Grafana dashboards. Alerts notify the operations team proactively, and logs are correlated centrally for faster debugging.

Documentation and Knowledge Transfer

Confluence pages were cleaned up and replaced with developer onboarding materials that reflect the new system. Processes are now repeatable and no longer tied to tribal knowledge.

Implementation Process

• Discovery and Architecture Assessment: audit of existing VMs, configuration sources, dependencies, and runtime environments.
• Team Coaching and DevOps Enablement: workshops covering Git workflows, container basics, Kubernetes fundamentals, and GitOps principles.
• Creation of EPICS and stories: structured backlog for technical migration and cultural change.
• Infrastructure as Code: introduction of Terraform for AKS, Key Vault, network policies, and monitoring setup.
• Application Containerisation: moving legacy services into Docker images with standardised CI pipelines.
• GitOps Rollout: defining Helm charts, manifests, and ArgoCD applications for each environment.
• Monitoring, Logging, and Alerting: enabling transparency into application health and performance.
• Security Hardening: removing plaintext secrets, adding RBAC, setting up cluster policies, and preventing configuration drift.

Results Achieved

• Version Control Everywhere: all code and infrastructure changes are traceable and auditable.
• Automated Deployments: manual VM work is replaced with push-button releases and GitOps workflows.
• Consistent Environments: no more configuration drift or undocumented VM snowflakes.
• Faster Incident Response: real monitoring and alerting reduce downtime and improve customer satisfaction.
• Improved Security: secrets are encrypted, rotated, and centrally managed.
• Developer Empowerment: teams can deploy and test confidently without depending on manual ops work.
• Higher Release Velocity: safe automation enables smaller, more frequent deployments.

Lessons Learned

Legacy modernisation is as much a cultural shift as a technical one. Teams benefited most once Git became the single source of truth and deployments were automated. Replacing undocumented VM changes with versioned manifests dramatically reduced operational risk. Early investment in developer training and process alignment proved essential for long-term success.

The next steps include further refactoring of legacy services, implementing stronger CI practices such as automated testing, and extending observability with SLOs and tracing.