{"version":"bb1f69edff80","docs":[{"id":"profile/summary","title":"Rakshith S P: Principal Platform Engineer","url":"/","section":"Summary","text":"Rakshith Siragaje Ponnappa (Rakshith S P) is a Principal Platform Engineer based in Bengaluru, India, focused on Cloud platforms, SRE & AI agent infrastructure. I build and run the platforms enterprises and AI teams depend on: landing zones, Kubernetes, Terraform and secure delivery pipelines across Azure, AWS and GCP, and the sandboxed environments where AI agents are trained and evaluated. The discipline is the same everywhere: infrastructure as code, guardrails, evals, observability and a tested way back. I lead technical delivery across enterprise programmes and set the engineering standards. Career started in August 2014. At a glance: 12+ years in cloud & DevOps; 500+ VMs migrated to Azure with DR; 18 certifications; 4 clouds: Azure · AWS · GCP · Huawei; 4 yrs on-ground in Dubai & Oman; 20+ enterprise clients across UK, US & GCC. Open to: Platform engineering leadership, SRE, AI infrastructure and forward-deployed engineering roles."},{"id":"profile/contact","title":"Contact","url":"/contact/","section":"Contact","text":"You can contact Rakshith S P by email at contact@rakshithponnappa.com or by phone on +91 90354 00153. LinkedIn: https://www.linkedin.com/in/rakshith-siragaje-ponnappa-60809355/. GitHub: https://github.com/rakshith-ponnappa. He is based in Bengaluru, India (IST), and the Open a ticket form on the contact page reaches him directly. The résumé PDF is at https://rakshithponnappa.com/Rakshith_SP_Resume.pdf."},{"id":"profile/experience/ensono","title":"Expert Technology Consultant – DevOps (Principal Consultant) at Ensono","url":"/experience/","section":"Experience","text":"Ensono: Expert Technology Consultant – DevOps (Principal Consultant), Dec 2022 to Present (full-time), Bengaluru · remote delivery to UK, US & GCC clients. Senior technical lead across concurrent enterprise programmes: set the engineering standards for CI/CD, IaC, security scanning and release management, guide the engineers who deliver them and advise client leadership on architecture. Designed reusable GitLab CI templates with OIDC multi-cloud authentication and MR-gated SAST, DAST and secret detection, adopted across engagements. State Street (PFI): lead architect, end to end, for an NTT data-centre exit to Azure; built the Terraform module library from scratch (VM, SQL MI, Oracle, load balancer, Front Door, Key Vault/DES, ASR, RSV), provisioned 500+ VMs configured for DR, and ran 3 production cutovers that put 10+ applications live. State Street (PFI): cross-region DR on Azure Site Recovery (private-endpoint CMK vault, batch recovery plans, SQL MI geo-failover, RPO target under 15 min); split 35,000 Terraform resources into per-app TFE workspaces and Harness pipelines with zero reboots; built a golden-image VM factory that cut VM builds from 30 to 2–3 minutes. Five Below: Azure landing zone audit (WAF 8.0 static / 6.6 runtime, CIS); remediation roadmap cut critical findings by 75%; $47K annual savings identified. Mott MacDonald: ALZ QA build-out, Terraform connectivity fixes, GitHub Actions architecture; ADO → Harness migration feasibility with a 5-week phased plan. Clients and workstreams: State Street (DC exit · 500+ VMs · DR · TFE split), Five Below (LZ audit), Mott MacDonald (ALZ QA), Kingfisher (Policy-as-code), Menzies (Multi-account LZ), EZCorp (Databricks / network)."},{"id":"profile/experience/gitlab","title":"Professional Services Engineer at GitLab","url":"/experience/","section":"Experience","text":"GitLab: Professional Services Engineer, Oct 2026 to Present (contract), Remote · contract · customer: Crédit du Maroc (banking, Morocco). With GitLab Professional Services (contract), one of two engineers upgrading Crédit du Maroc’s self-managed GitLab from 12.x towards 19.x, one required stop at a time, on the bank’s live CI/CD estate. Execute the multi-hop upgrade path (27 hops in phase 1), each hop rehearsed on a copy of live data and promoted only on evidence, with the untouched copy as the rollback. Run maintenance windows end to end: runner traffic blocked at the proxy, background migrations drained, PostgreSQL upgrades at major versions, validation scripts before and after, then a test pipeline and a written report per hop. Turned the method into a public, field-tested runbook: gitlab-omnibus-upgrade-playbook. Clients and workstreams: Crédit du Maroc (GitLab upgrade)."},{"id":"profile/experience/turing","title":"DevOps Engineer, AI Agent Training Platform at Turing","url":"/experience/","section":"Experience","text":"Turing: DevOps Engineer, AI Agent Training Platform, Sep 2026 to Nov 2026 (contract), Remote · contract. Built and ran the sandboxed desktop environments where computer-use AI agents are trained and evaluated, on an agent training and benchmark platform for a frontier AI lab. Built the sandboxed Linux desktop image (GNOME, arm64) that computer-use agents operate in, and ported the agent evaluation harness to a new managed sandbox provider. Ran the sandbox-provider migration analysis and proof of concept, and black-box conformance and security testing of the sandboxes: network egress policy, cloud-metadata probes, quota limits, snapshots, PTY/SSH/Git and secrets, with captured evidence and retests of vendor fixes. Platform DevOps on GCP Cloud Run with Jenkins and GitHub Actions: stood up the develop branch and staging environment, and designed the dev environment (design note plus Terraform for bootstrap, dev and prod). Agentic-coding training data: refined Codeforces-style tasks, validated brute-force and optimal reference solutions, wrote reasoning traces and built Docker test suites. Clients and workstreams: Agent sandboxes (computer-use), Platform DevOps (Cloud Run), Agentic coding data."},{"id":"profile/experience/planhub","title":"Site Reliability & Platform Engineer (Freelance) at PlanHub","url":"/experience/","section":"Experience","text":"PlanHub: Site Reliability & Platform Engineer (Freelance), Jun 2023 to Jul 2025 (contract), Remote · US construction-tech SaaS. Freelance SRE and platform engineer for PlanHub, the US preconstruction marketplace that connects general contractors, subcontractors and suppliers: ran the AWS developer platform and kept production reliable. Owned the AWS platform in Terraform: VPC, RDS PostgreSQL with read replicas, ALB, NAT, Route 53 and ACM, with containerised services on ECS Fargate, ECR and CloudWatch logging. Ran the developer platform: QA/UAT/Prod CI/CD on CodePipeline, CodeBuild and CodeDeploy with GitHub and Slack, and Boto3 blue/green cut-overs for zero-downtime releases across 5 service tiers. Automated routine operations: 7 EventBridge-scheduled Lambda jobs for archival, cleanup and push notifications. Security and compliance: HIPAA- and GDPR-aligned encryption, IAM and data-handling controls; 39 SSH keys moved into 1Password; ClamAV scanning across the estate. Data platform: Fivetran → Redshift behind a bastion host, with private QuickSight access over the VPC. Clients and workstreams: PlanHub (AWS platform & SRE)."},{"id":"profile/experience/ozone","title":"Site Reliability Engineer at Ozone (Huco FZCO)","url":"/experience/","section":"Experience","text":"Ozone (Huco FZCO): Site Reliability Engineer, Sep 2019 to Dec 2022 (full-time), On-ground in Dubai, UAE (3 yrs) & Oman (1 yr). GCC on-site delivery for DU Telecom, Etisalat, RAK Bank, Dubai Municipality and Petroleum Development Oman. Built self-hosted GitLab on Kubernetes with security-integrated pipelines for RAK Bank and DU Telecom. Deployed GKE, EKS and AKS with network policies and Cloud NAT; built Tanzu (TKGS) on vSphere 7 for a Blockchain-as-a-Service platform. Ran Istio, Harbor, Fluentd, Jaeger and Kasten in production. Real-time pipelines on AWS Kinesis and Confluent Kafka; multi-cloud network security with Private Link, VPC peering and IAM. Clients and workstreams: DU Telecom, Etisalat, RAK Bank, Dubai Municipality, PDO (Oman)."},{"id":"profile/experience/intuitive","title":"DevOps Engineer at Intuitive Technology Partners","url":"/experience/","section":"Experience","text":"Intuitive Technology Partners: DevOps Engineer, May 2018 to Sep 2019 (full-time), Bengaluru. Platform engineering on AWS EKS. Architected an AWS EKS platform prototype to onboard 20 clients and migrate 30,000 websites, including capacity planning and cost control. Deployed SignalFx real-time EKS monitoring with custom dashboards and proactive alerting. Clients and workstreams: 30,000-site EKS migration."},{"id":"profile/experience/capgemini","title":"Associate Consultant at Capgemini","url":"/experience/","section":"Experience","text":"Capgemini: Associate Consultant, Aug 2014 to May 2018 (full-time), Bengaluru · UK & Europe delivery. Cloud migration, architecture and CI/CD for UK and European enterprises. Cloud transition, architecture and CI/CD delivery for Carnival, Grant Thornton, Esure, Heathrow Airport, Anglian Water, Ikano and Eneco. Clients and workstreams: Carnival, Heathrow, Grant Thornton, Esure, Anglian Water, Ikano, Eneco."},{"id":"profile/certifications","title":"Certifications","url":"/credentials/","section":"Certifications","text":"Rakshith S P holds 18 certifications: Microsoft Agentic AI Business Solutions Architect (AB-100); AWS AI Practitioner; Microsoft Azure AI Fundamentals; AWS Solutions Architect – Professional; AWS DevOps Engineer – Professional; AWS Solutions Architect – Associate; Microsoft DevOps Engineer Expert (AZ-400); Microsoft Azure Administrator (AZ-104); Microsoft Azure Security Engineer; Microsoft Azure Developer Associate; Microsoft MCSA: Cloud Platform; Google Cloud Associate Cloud Engineer; CNCF Certified Kubernetes Administrator (CKA); HashiCorp Terraform Associate; VMware Cloud-Native Master Specialist; Red Hat Container Platform; Palo Alto Prisma Cloud Associate; AXELOS ITIL Foundation."},{"id":"profile/education","title":"Education","url":"/credentials/","section":"Education","text":"Education and degrees: Master of Computer Applications, Bharathidasan University, 2016 – 2018; Bachelor of Computer Applications, CMR Institute of Management Studies, 2011 – 2014. He studied at Bharathidasan University (MCA) and CMR Institute of Management Studies (BCA). Additional coursework (a course, not a degree): IoT, Cloud & Blockchain, IIT Madras, 2024."},{"id":"profile/skills/cloud","title":"Skills: Cloud","url":"/experience/#skills-title","section":"Cloud","text":"Cloud skills and tools Rakshith S P has worked with and used in production: Azure, AWS, GCP (incl. Cloud Run), Huawei Cloud (G42), VMware Tanzu, OpenShift. He has worked on four clouds (Azure, AWS, Google Cloud and Huawei Cloud) plus VMware Tanzu and OpenShift platforms."},{"id":"profile/skills/infrastructure-as-code","title":"Skills: Infrastructure as code","url":"/experience/#skills-title","section":"Infrastructure as code","text":"Infrastructure as code skills and tools Rakshith S P has worked with and used in production: Terraform / TFE, CloudFormation, Ansible / Tower, Packer, Helm."},{"id":"profile/skills/kubernetes--cloud-native","title":"Skills: Kubernetes & cloud native","url":"/experience/#skills-title","section":"Kubernetes & cloud native","text":"Kubernetes & cloud native skills and tools Rakshith S P has worked with and used in production: AKS, EKS, GKE, TKGS, Rancher, K3s, Istio, Linkerd, Envoy, Harbor, Kasten."},{"id":"profile/skills/cicd--gitops","title":"Skills: CI/CD & GitOps","url":"/experience/#skills-title","section":"CI/CD & GitOps","text":"CI/CD & GitOps skills and tools Rakshith S P has worked with and used in production: GitHub Actions, GitLab CI, Jenkins, Azure Pipelines, AWS CodePipeline, Harness, Tekton."},{"id":"profile/skills/devsecops","title":"Skills: DevSecOps","url":"/experience/#skills-title","section":"DevSecOps","text":"DevSecOps skills and tools Rakshith S P has worked with and used in production: Checkov, Prisma Cloud, AquaSec, Snyk, SonarQube, SAST/DAST, Vault, OIDC."},{"id":"profile/skills/observability","title":"Skills: Observability","url":"/experience/#skills-title","section":"Observability","text":"Observability skills and tools Rakshith S P has worked with and used in production: Prometheus, Dynatrace, New Relic, ELK/EFK, Jaeger, CloudWatch, Azure Monitor, PagerDuty."},{"id":"profile/skills/ai","title":"Skills: AI","url":"/experience/#skills-title","section":"AI","text":"AI skills and tools Rakshith S P has worked with and used in production: LLM evaluation, Multi-agent systems, RAG & retrieval evals, MCP / A2A, Azure AI Foundry, Copilot Studio, Ollama."},{"id":"profile/skills/data","title":"Skills: Data","url":"/experience/#skills-title","section":"Data","text":"Data skills and tools Rakshith S P has worked with and used in production: Databricks, Redshift, Fivetran, Kafka, Kinesis, OpenSearch."},{"id":"profile/skills/code","title":"Skills: Code","url":"/experience/#skills-title","section":"Code","text":"Code skills and tools Rakshith S P has worked with and used in production: Python (Boto3, FastAPI), Bash, HCL, TypeScript, YAML."},{"id":"profile/field","title":"Field deployments","url":"/experience/#field-title","section":"Field deployments","text":"On-site field deployments and locations: Dubai, UAE: 3 yrs on-ground, DU · Etisalat · RAK Bank · Dubai Municipality. Muscat, Oman: 1 yr on-ground, Petroleum Development Oman. Bengaluru, India: Home base, Remote delivery to UK, US & GCC. Four years on the ground in the Gulf (Dubai, UAE and Muscat, Oman) with Ozone."},{"id":"work/state-street-azure-landing-zone-dr","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/","section":"Summary","text":"State Street (PFI): As lead architect I took State Street's PFI estate out of an NTT data centre and onto Azure end to end. I built the Terraform module library from scratch, stood up 500+ VMs with SQL Managed Instance, Oracle, load balancing and cross-region DR, and ran three production cutovers that put 10+ applications live. Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street. Client: State Street (PFI) (Financial services), delivered via Ensono, 2022 – present. Role: Lead Cloud Architect, end to end (Terraform module design, migration, DR & cutover). 500+ VMs built from my modules and configured for DR; 10+ applications migrated and live in production; 3 production cutovers from the NTT data centre; < 15 min steady-state RPO target for replicated VMs. Stack: Terraform Enterprise, Custom Terraform modules, Azure Virtual Machines, SQL Managed Instance, Oracle on Azure, Azure Load Balancer, Azure Front Door, Azure Site Recovery, Recovery Services Vault, Key Vault & disk encryption sets, Private endpoints, Harness, OPA policy, Ansible Tower."},{"id":"work/state-street-azure-landing-zone-dr#context","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#context","section":"Context","text":"State Street's PFI programme was moving a regulated production estate out of an NTT-hosted data centre and onto Azure: several applications, hundreds of Windows servers, SQL databases and Oracle, all of which had to land in a governed landing zone with disaster recovery from day one. I was the lead architect, end to end. I designed the target platform, built the Terraform module library it runs on, provisioned the estate, designed DR, and led the production cutovers."},{"id":"work/state-street-azure-landing-zone-dr#constraints","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#constraints","section":"Constraints","text":"- Regulated and in production. Every resource had to be code-defined, reviewed and traceable. Nothing was built by hand in the portal, and policy gates (OPA) checked every plan. - A live data-centre exit. Applications had to move without losing data or breaking downstream integrations, so each cutover had a fixed window and a rehearsed rollback. - DR from day one. Workloads couldn't land in Azure and get DR \"later\". Replication, recovery plans and database failover had to be part of the build. - Private and customer-keyed. Disks, vaults and key vaults used customer-managed keys, and control and replication traffic ran only over private endpoints. - Scale and blast radius. 500+ VMs and five applications shared one Terraform estate, so module design and state layout decided how safe every later change would be."},{"id":"work/state-street-azure-landing-zone-dr#what-i-did","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#what-i-did","section":"What I did","text":"1. Designed and built the Terraform module library from scratch, to State Street's standards. Each module carries its own tagging, policy and encryption conventions:  - VMs: Windows VMs with a disk encryption set per VM (CMK from Key Vault), availability zones, NICs, boot diagnostics, VM extensions and data-collection-rule associations, driven from for_each maps in tfvars. - SQL Managed Instance: instances with Entra admin, plus geo-failover groups to the DR region. - Oracle: the Oracle workloads deployed as part of the migration. - Traffic: internal Azure Load Balancers with backend pools resolved by NIC, and Azure Front Door at the edge. - Security: Key Vaults, disk encryption sets, managed identities and RBAC. - DR: a Recovery Services Vault and an ASR replication module. 2. Provisioned the estate: 500+ VMs across five applications, each mapped to its SQL Managed Instance tier and fronted by its load balancers. Everything went through reviewed pipelines and Terraform Enterprise behind OPA policy checks, including 12 mandatory governance tags on every resource group. 3. Built cross-region DR into the platform. - Vault: a Recovery Services Vault reachable only through private endpoints and encrypted with customer-managed keys, with ASR cache storage in the source region and CMK-encrypted replica disks in the DR region."},{"id":"work/state-street-azure-landing-zone-dr#what-i-did-2","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#what-i-did","section":"What I did","text":"- Recovery plans: VMs are batched into replication groups of 16, each with its own recovery plan, so failover, test failover, re-protect and failback run batch by batch. - Databases: SQL Managed Instances fail over through geo-failover groups. - Monitoring: alerts cover replication health, RPO breaches, re-protect state and test failovers older than 90 days. 4. Migrated the applications and ran three production cutovers from the NTT data centre. Each wave followed the same rehearsed sequence: freeze, final sync, switch traffic and DNS, validate (domain authentication, service start-up, database listeners), then decommission the source. 10+ applications are now live in production on Azure. 5. Wrote the runbooks and handed over. Runbooks cover adding or removing VMs from DR, test failover, failover, commit, re-protect and failback, plus knowledge-transfer sessions so the client team can operate the platform. 6. Then: splitting the Terraform estate. The estate grew to 35,000 resources in one state, so I led the split into one workspace, repository and Harness pipeline per application, moving delivery from Azure DevOps to Harness without rebooting a production VM. 7. And: a VM factory."},{"id":"work/state-street-azure-landing-zone-dr#what-i-did-3","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#what-i-did","section":"What I did","text":"Replacement VM builds needed reruns and waited on security onboarding, so I designed and built a VM factory with an image bakery: a versioned golden image and one gated Harness flow that cut VM build time from about 30 minutes to 2–3. 8. Alongside: DR readiness drills with the platform team (Active Directory, Kerberos and DNS during failover; 54 secondary VMs cleaned up afterwards)."},{"id":"work/state-street-azure-landing-zone-dr#key-decisions","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Build a module library instead of per-app Terraform One VM, SQL MI, load balancer and DR pattern for every application keeps 500+ VMs consistent, reviewable and policy-compliant. More upfront design. Modules must stay backwards-compatible as applications adopt them. A disk encryption set per VM, keys in Key Vault Customer-managed encryption with a per-VM boundary, rotatable without rebuilding VMs. More resources to manage and a hard dependency on the shared key vault. DR in the build, not after it An estate that lands without replication is exposed from its first day in production. Initial replication of hundreds of VMs takes days, so it had to be staged in waves. Recovery plans per batch of 16 VMs Failover and testing run in manageable units, and one bad batch doesn't block the rest. Batches depend on list order, so the VM list can only ever be appended to. Three cutover waves, not a big bang Each wave proved the runbook and limited the blast radius of a bad night. A longer programme, with temporary hybrid connectivity between the data centre and Azure. Databases fail over before VMs Applications that start before their database is primary in the DR region fail on start-up. Failover is a two-step runbook instead of one button."},{"id":"work/state-street-azure-landing-zone-dr#key-decisions-2","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#key-decisions","section":"Key decisions","text":"Split state by carving it, not by re-importing The VM modules carry reboot provisioners, so re-importing would replace them and reboot production. Carving copies state verbatim and keeps the plan at zero changes. Needs platform-team state permissions and a frozen workspace during the carve. Why the module design mattered most At 500+ VMs, the module is the platform. Every VM inherits its encryption, diagnostics, monitoring and DR wiring from the same code path. A new application is then a tfvars change, not a new design, and a fix lands everywhere in one reviewed change. The modules also pass plain identifiers between each other: load balancers resolve backends by NIC name, and ASR takes {vm_name, resource_group} pairs. That is what made it possible to later split the state per application without rewiring anything. Why identity matters in a cutover and a failover Kerberos depends on name resolution. A VM that boots in Azure, whether after a cutover or a failover, has to resolve correctly and be resolved, or domain logins fail while the portal shows a healthy machine. That's why every cutover and failover runbook validates domain authentication, service start-up and the database listener, not just that the VM is running."},{"id":"work/state-street-azure-landing-zone-dr#outcome","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#outcome","section":"Outcome","text":"- NTT data-centre exit delivered: 3 production cutovers, with 10+ applications live on Azure. - 500+ VMs built from a Terraform module library I designed from scratch, mapped to SQL Managed Instances with Oracle workloads deployed, behind Azure Load Balancer and Front Door. - Cross-region DR across the estate: ASR with a private-endpoint, customer-managed-key vault; batch-level recovery plans; SQL MI geo-failover groups; a steady-state RPO target under 15 minutes; and alerting. - Runbooks and knowledge transfer, so the client team operates the platform. - Follow-on work on the same estate: a 35,000-resource Terraform split per application, and a VM factory and image bakery."},{"id":"work/state-street-azure-landing-zone-dr#what-id-do-next","title":"Data-centre exit to Azure: 500+ VM estate, DR and live cutovers for State Street","url":"/work/state-street-azure-landing-zone-dr/#what-id-do-next","section":"What I'd do next","text":"- Make test failover routine. Rotate one recovery plan through a test failover each week, so every batch is proven on a calendar. - Build the DR side from the golden image. Rebuilding it from the image bakery's promoted versions means every patch-cycle release also refreshes the recovery estate. - Run continuous compliance per workspace. With per-application state, run drift and policy checks per application on a schedule, not just at deploy time."},{"id":"work/agentic-benchmark-devops-ai-eval","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/","section":"Summary","text":"Turing (contract): On an AI agent training and benchmark platform for a frontier AI lab, I built and ran the sandboxed desktop environments where computer-use agents are trained and evaluated: the desktop image, the evaluation harness port to a new sandbox provider, the provider migration analysis, conformance and security testing of the sandboxes, and the delivery path from develop to staging on Cloud Run. Sandboxed environments for training and evaluating computer-use AI agents. Client: Turing (contract) (AI agent training & evaluation), delivered via Turing, Sep – Nov 2026 (contract). Role: DevOps Engineer, AI Agent Training Platform. 1 → 2 sandbox providers the evaluation harness runs on; 9 test areas in the sandbox conformance & security suite; develop + staging environments stood up on Cloud Run. Stack: Agent sandboxes, Linux desktop images (GNOME, arm64), Docker, GCP Cloud Run, Jenkins, GitHub Actions, Terraform, Python, Network egress policy, Codeforces-style tasks."},{"id":"work/agentic-benchmark-devops-ai-eval#context","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#context","section":"Context","text":"Computer-use agents learn and are scored by operating a real desktop: opening apps, clicking, typing and reading the screen. The platform I worked on trains and benchmarks these agents for a frontier AI lab, so it runs many short-lived sandboxed desktops. Each one has to start fast, behave identically every time, and contain whatever the agent does inside it. On this contract with Turing my part was the infrastructure side of that: the sandbox environments themselves, moving the evaluation harness onto a new managed sandbox provider, proving that provider was safe and fit for purpose, and the delivery path for the platform. Alongside it I produced agentic-coding training data."},{"id":"work/agentic-benchmark-devops-ai-eval#constraints","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#constraints","section":"Constraints","text":"- Reproducibility is the product. A benchmark score only means something if every agent sees exactly the same desktop. Image drift is a correctness bug, not a cosmetic one. - The agent is untrusted code. Whatever it runs must stay inside the sandbox: no unexpected network egress, no route to cloud metadata endpoints, no leaked credentials. - Provider claims aren't evidence. Lifecycle, snapshots, quotas and network policy had to be verified by testing, not taken from documentation. - A live platform. Researchers depend on results while the infrastructure changes, so every change needs a place to fail safely before production. - Confidentiality. Client and vendor details stay private, so this write-up describes the engineering, not the names."},{"id":"work/agentic-benchmark-devops-ai-eval#what-i-did","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#what-i-did","section":"What I did","text":"Sandbox environments for computer-use agents 1. Built the desktop image. I built the sandboxed Linux desktop image (GNOME, arm64) that agents operate in, with the tooling the tasks need baked in, so every episode starts from an identical, known state. 2. Ported the evaluation harness to a new sandbox provider. I adapted the harness's provider layer (create, snapshot, execute, observe, tear down) so the same tasks and scoring run on a second managed sandbox provider without changing the benchmark. 3. Ran the provider migration analysis and proof of concept. I wrote the requirements, compared feature parity and operating model, and built the proof of concept that showed what a migration would involve and where the gaps were. 4. Tested the sandboxes as a black box. I built a conformance and security suite covering nine areas: end-to-end user journeys and templates, snapshots, network egress policy, cloud-metadata probes, quotas and stress, Git, PTY, SSH, and secrets handling. Every run captured evidence, so findings went to the vendor as reproducible reports, and I retested their fixes before signing off. Platform delivery 5. Develop branch and staging on Cloud Run. On GCP Cloud Run, with Jenkins and GitHub Actions in the delivery path, I stood up a develop branch and a staging environment, so changes integrate and run somewhere production-like before release. 6."},{"id":"work/agentic-benchmark-devops-ai-eval#what-i-did-2","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#what-i-did","section":"What I did","text":"Designed the dev environment. I wrote the dev-environment design note and drafted the Terraform for it: bootstrap, dev and prod environments, and shared modules. Agentic-coding training data 7. Built training tasks that hold up. I refined LLM-generated, Codeforces-style problems for clarity, constraints and correctness. I validated brute-force and optimal reference solutions against each other, wrote reasoning traces and metadata, and built Docker test suites and plagiarism checks for each task."},{"id":"work/agentic-benchmark-devops-ai-eval#key-decisions","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Bake the desktop into a versioned image Identical start state for every episode is what makes scores comparable. Image builds to maintain, and every change goes through a rebuild. Abstract the provider behind the harness The benchmark shouldn't care which sandbox runs it, so providers can be swapped or run side by side. An interface to keep honest as providers differ in what they support. Black-box tests with captured evidence Verifies behaviour the platform actually depends on, and gives a vendor something reproducible to fix. More upfront work than a checklist review. Egress and metadata probes as first-class tests An agent that can reach the network or cloud metadata unexpectedly is a security incident, not a flaky test. Probes must be precise enough to avoid false alarms. Pair a develop branch with a staging environment Integration problems surface in staging, not in front of the researchers using the results. Another environment to keep in step with production. Why sandbox testing is platform engineering Sandboxes for AI agents fail the same way any multi-tenant platform does: an isolation boundary that leaks, a quota that behaves differently at the edge, a snapshot that doesn't restore what you think. The answer is also the same: define the contract, test it from outside, keep the evidence, and don't trust a fix until it passes the same test. I've since published a vendor-neutral version of the approach as the agent-sandbox-conformance-kit."},{"id":"work/agentic-benchmark-devops-ai-eval#outcome","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#outcome","section":"Outcome","text":"- Computer-use agents run in a reproducible, hardened desktop image. - The evaluation harness runs on a second managed sandbox provider, backed by a migration analysis and proof of concept. - A nine-area conformance and security suite with captured evidence; findings reported to the vendor and fixes retested. - The platform gained a develop branch and a Cloud Run staging environment, and a designed, Terraform-backed dev environment. - Agentic-coding training tasks delivered with validated solutions, reasoning traces and Docker test suites. I'm not quoting client names, task volumes or scores; the deliverables were the environments, the tests and a safer release path."},{"id":"work/agentic-benchmark-devops-ai-eval#what-id-do-next","title":"Sandboxed environments for training and evaluating computer-use AI agents","url":"/work/agentic-benchmark-devops-ai-eval/#what-id-do-next","section":"What I'd do next","text":"- Run the conformance suite in CI against every provider, nightly, so a provider regression shows up before an evaluation run does. - Promote images by digest. Build each desktop image once and promote the same digest from staging to production. - Per-pull-request previews. Cloud Run revision tags give each change its own URL without taking traffic."},{"id":"work/state-street-terraform-enterprise-split","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/","section":"Summary","text":"State Street (PFI): State Street's whole Azure estate (35,000 Terraform resources across five applications) lived in one state file. Plans were slow, locks were shared and every change put the whole estate at risk. I designed and led the split into one state, workspace, repository and pipeline per application, moving delivery from Azure DevOps to Harness and Terraform runs into Terraform Enterprise, without recreating or rebooting a production VM. Splitting 35,000 Terraform resources into per-app state, with zero reboots. Client: State Street (PFI) (Financial services), delivered via Ensono, 2026. Role: Lead architect, end to end (state design, carve method, pipeline and TFE migration). 35,000 Terraform resources carved out of a single state; 1 → 5 monolithic workspace split into per-application workspaces; 0 production VMs recreated or rebooted by the carve; 0 planned changes required after each carve. Stack: Terraform Enterprise, Terraform state surgery, OPA policy, Harness, Azure DevOps, Azure Site Recovery, Key Vault & disk encryption sets, Git branch protection."},{"id":"work/state-street-terraform-enterprise-split#context","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#context","section":"Context","text":"After the data-centre exit, State Street's PFI estate was healthy but held in one Terraform state. That single workspace held about 35,000 resources across five applications: VMs, disk encryption sets, NICs, load balancers, SQL Managed Instances, Oracle, Key Vault wiring and the Azure Site Recovery estate. Delivery ran through Azure DevOps pipelines. That shape had stopped scaling: - Every plan refreshed everything. A one-line change to one application meant refreshing all 35,000 resources, so plans were slow and noisy. - One lock for five teams. Only one run could hold the state, so unrelated changes queued behind each other. - The blast radius was the whole estate. A bad variable or module bump for one application showed up in a plan that touched all five. - Hard to review and to govern. Huge plans hide the one change that matters, and policy checks ran against the whole estate every time. I owned the split end to end: target design, the carve method, the pilot, and the move of pipelines and runs to Harness and Terraform Enterprise."},{"id":"work/state-street-terraform-enterprise-split#constraints","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#constraints","section":"Constraints","text":"- No production impact. The VM modules carry provisioners (null_resource with triggers) that restart or reconfigure VMs when they are created. Any approach that recreated them would reboot production. - Policy says no. OPA policy on Terraform Enterprise blocks plans that forget or destroy managed resources, so removed blocks plus import in the new workspaces weren't an option. Rightly so: that pattern briefly leaves resources unmanaged. - moved only works inside one state. Terraform's refactoring blocks can't move resources between workspaces. - Shared resources stay shared. Key vaults, disk encryption sets, the boot-diagnostics storage account and the DR estate (Recovery Services Vault, replication policy and fabric) are used by every application and had to keep exactly one owner. - DR ordering is append-only. VMs are batched into ASR replication groups of 16 by list position. Re-ordering the list would reshuffle protected VMs between recovery plans. - Regulated change. Every step needed a reviewed plan, an approval and a rollback."},{"id":"work/state-street-terraform-enterprise-split#what-i-did","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#what-i-did","section":"What I did","text":"1. Mapped every address to an owner. I classified all 35,000 resource addresses by application (module keys, tags and naming) and by role: app-owned, shared platform or DR. I also listed every cross-application reference. This map drove the whole split. 2. Designed the target layout. - Shared platform workspace: key vaults, disk encryption sets, diagnostics storage and the whole DR estate, so the ASR batch order stays in one place and untouched. - One workspace, repository and pipeline per application: each application's VMs, data tier, load balancers and app-level wiring. - Data sources, not references: application workspaces read shared resources through data sources (and published outputs), so no application can change a shared resource by accident. 3. Designed the carve: state surgery, not re-import. For each application:  - Freeze: lock the source workspace and stop the pipelines. - Snapshot: run terraform state pull, keep a versioned backup and record the serial. - Split: move that application's addresses into a new state file offline, check resource counts against the address map and set fresh lineage for the new state. - Push: the platform team pushes the slice to the new Terraform Enterprise workspace (state-write permissions held by them), then the carved addresses are removed from the source. - Verify: both workspaces must plan zero changes before anything unlocks."},{"id":"work/state-street-terraform-enterprise-split#what-i-did-2","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#what-i-did","section":"What I did","text":"Any diff means the snapshot is restored. Resources move verbatim and nothing is recreated, so no provisioner fires and no VM reboots. 4. Piloted with the smallest application, then carved the rest. I proved the full carve, the data-source swaps and a zero-change plan on the smallest application, then carved the remaining four the same way. 5. Moved delivery from Azure DevOps to Harness. Every application got its own Harness pipeline:  - pull request → speculative plan in Terraform Enterprise → OPA policy check → approval → apply, through the TFE API;  - Azure DevOps service connections, variable groups and secrets became Harness connectors, variables and secret references. 6. Moved Terraform execution into Terraform Enterprise. Before, Azure DevOps agents ran the Terraform CLI against one big workspace. Now plans and applies execute inside per-application TFE workspaces, with their own run history, policy sets attached per workspace and shared settings in variable sets. The pipeline orchestrates; it no longer runs Terraform itself. 7. Put guardrails on the new shape. - Branch protection and code owners on every repository. - 12 mandatory governance tags enforced by policy. - Shared-resource changes go only through the platform workspace. - The ASR list stays append-only, documented in the runbook."},{"id":"work/state-street-terraform-enterprise-split#key-decisions","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Carve state instead of re-importing Re-import would recreate provisioners and reboot production VMs, and removed + import is blocked by policy. Carving keeps every resource as-is. Needs platform-team state permissions, a frozen workspace and careful offline handling of the state. Zero-change plan as the exit gate It is the only objective proof that the carve lost nothing and changed nothing. A diff of even one resource means rolling back and repeating. Shared and DR resources in one platform workspace One owner for keys, encryption, diagnostics and DR, and the ASR batch order can't drift. Application teams depend on platform outputs and their release cadence. Data sources between workspaces Applications read shared resources but can't change them. The coupling is explicit and one-way. A shared-resource rename has to be co-ordinated across workspaces. Smallest application first The method is proven where a mistake affects the fewest VMs. The biggest wins (the largest applications) arrive last. Migrate pipelines and split state together Each application lands once on its final shape (own repo, TFE workspace, Harness pipeline) instead of being migrated twice. A bigger cutover per application, so each one is rehearsed. Why not just terraform state mv between workspaces? With remote state in Terraform Enterprise there is no safe \"move between workspaces\" button. The source and target are separate state versions with their own lineage and serials. Working on a pulled snapshot, splitting it offline and pushing each slice deliberately turns that into a reviewed, repeatable and reversible operation. The snapshot is the rollback."},{"id":"work/state-street-terraform-enterprise-split#outcome","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#outcome","section":"Outcome","text":"- One monolithic state of 35,000 resources redesigned into one shared platform workspace plus one workspace, repository and Harness pipeline per application. - All five applications carved, each on its own workspace and pipeline, with no recreated or rebooted VMs and a zero-change plan as the gate for every carve. - Delivery moved from Azure DevOps to Harness, and Terraform runs into Terraform Enterprise with OPA policy per workspace. - Smaller plans, separate locks and per-application blast radius: one team's change no longer waits on, or risks, another team's estate. - Guardrails that keep the shape: branch protection, code owners, governance tags and one owner for shared and DR resources. The VM factory builds into the same per-application workspaces."},{"id":"work/state-street-terraform-enterprise-split#what-id-do-next","title":"Splitting 35,000 Terraform resources into per-app state, with zero reboots","url":"/work/state-street-terraform-enterprise-split/#what-id-do-next","section":"What I'd do next","text":"- Automate drift checks. A scheduled zero-change plan per workspace, with an alert on drift. - Publish module versions. Move the module library to a private registry with semantic versions, so each application upgrades on its own schedule. - Script the carve. Turn the runbook into a tested tool (address map in, split states and verification out) for the next estate that needs it."},{"id":"work/state-street-vm-factory-image-bakery","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/","section":"Summary","text":"State Street (PFI): Replacement VM builds at State Street took six steps across four tools, some needed two or three reruns, and security onboarding could add a week. I designed and built a VM factory end to end: a versioned golden image from an image bakery, reusable Terraform and Ansible templates, and one Harness-orchestrated flow with readiness gates. VM build time fell from about 30 minutes to 2–3. VM factory & image bakery: VM builds cut from 30 minutes to 2–3. Client: State Street (PFI) (Financial services), delivered via Ensono, 2026. Role: Lead architect, end to end (diagnosis, design, leadership pitch, build & rollout). 78 replacement VMs in the first factory scope; 6 → 1 separate build steps folded into one orchestrated flow; ~1 week security-onboarding wait moved ahead of the build window; 30 → 2–3 min VM build time with the golden image. Stack: Azure Image Builder, Packer, Azure Compute Gallery, Terraform Enterprise, Ansible, Harness, CyberArk, Azure Monitor Agent, Key Vault & disk encryption sets."},{"id":"work/state-street-vm-factory-image-bakery#context","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#context","section":"Context","text":"As part of the move from an NTT data centre to Azure, State Street needed replacement VMs: new Azure builds that take over from source servers. The building blocks worked, but the process didn't: - A VM passed through six separate steps across four tools: Terraform in three phases (disk encryption set, Key Vault RBAC, the VM itself), then Ansible/CD configuration, CyberArk enrolment and the application install. - Some VMs needed two or three runs before they were usable, and the same pipeline could fail differently from one run to the next. - CyberArk enrolment ran on a weekend cycle, so a VM could be finished from an infrastructure point of view and still wait up to about a week. - One application's install was manual and environment-specific. Each VM got over the line eventually. The problem was predictability: nobody could commit to a ready-date. I owned this end to end: I diagnosed the causes, designed the factory, took it to leadership, built it, piloted it and rolled it out."},{"id":"work/state-street-vm-factory-image-bakery#constraints","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#constraints","section":"Constraints","text":"- Regulated estate. No change to security controls. CyberArk, approvals and change management had to stay authoritative; only when they happen could move. - Existing tooling. The answer had to use what the bank already ran (Terraform Enterprise, Harness, Ansible, CyberArk, ServiceNow) and add no new platform. - Secrets never in images. Anything secret, environment-specific or fast-changing had to stay in the pipeline. - Live migration waves. The factory had to slot into a migration programme already in flight, starting with a low-risk pilot."},{"id":"work/state-street-vm-factory-image-bakery#what-i-did","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#what-i-did","section":"What I did","text":"1. Mapped the real build path. I traced 78 in-scope replacement VMs across two applications through every handoff: 78 disk encryption set targets, 78 VM module targets and 75 Ansible batches. That showed that reruns were hiding causes rather than fixing them. 2. Designed the image bakery. The rule: bake the baseline, pipeline the specifics. - Baked into the image: the approved OS baseline and hardening, monitoring agents (AMA), standard tools and prerequisites, and security and management agents. - Delivered by the pipeline: application install and configuration, secrets and certificates, environment settings, and anything that changes often. - Lifecycle: images are built with Azure Image Builder or Packer, versioned in an Azure Compute Gallery and rebuilt on the patch cycle. Terraform pins the image version, so every build is reproducible. 3. Built the factory flow in Harness. One trigger runs the whole build: golden image → provision (Terraform, per-app workspace, standard modules) → configure (Ansible, standard roles and inputs) → security gate → templated app install → app-ready, with one evidence record per VM. 4. Replaced reruns with gates. Readiness checks and controlled retries are built into the flow, and it stops early when a dependency is missing instead of failing halfway and being rerun. 5. Moved security onboarding forward."},{"id":"work/state-street-vm-factory-image-bakery#what-i-did-2","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#what-i-did","section":"What I did","text":"CyberArk readiness became a pre-build gate with a known turnaround, confirmed before the build window opens. The controls are the same; the order is different. 6. Templated the manual install. The environment-specific manual install became a reusable per-app pipeline stage, like the other applications'. 7. Took it to leadership, piloted it and rolled it out. I presented the case and the three decisions needed (adopt the factory, name one end-to-end owner, gate CyberArk early). The pilot ran on the smallest application first (4 VMs), then one batch of the large application, measuring build time before and after. It then became the standard build path."},{"id":"work/state-street-vm-factory-image-bakery#key-decisions","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Bake the baseline, pipeline the specifics Common components install once in a tested image instead of on every VM, so post-build time drops and every VM starts identical. An image lifecycle to own: builds, versions, patch-cycle rebuilds. Pin image versions in Terraform A build is reproducible and an upgrade is a reviewed one-line change. Images must be promoted deliberately, never \"latest\". One Harness flow instead of separate runs One trigger, one status and one place to see where a VM is stuck. Stage contracts between teams have to be agreed and kept. Gates and checks, not reruns A rerun that clears an error hides its cause, and the next wave hits it again. Checks take upfront effort to write and maintain. Security readiness before the build Infrastructure finishing early is worthless if the VM then waits a week for enrolment. Requests have to be raised earlier and tracked. Pilot on the smallest application, then roll out Proves the flow where a failure breaks 4 VMs, not 74. The large application waits one cycle longer. Designing ahead: AWS and an assistant layer The same pattern carries to AWS without repeating today's fragmentation."},{"id":"work/state-street-vm-factory-image-bakery#key-decisions-2","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#key-decisions","section":"Key decisions","text":"For AWS: - a migration factory: Application Migration Service waves, Migration Hub tracking and Application Discovery for dependencies; - golden images from EC2 Image Builder or Packer. For operators, an assistant layer answers \"where is this VM stuck, what failed in plain terms, what is the next approved action?\". It can trigger only pre-approved, audited workflows: Harness still runs pipelines, Terraform Enterprise runs Terraform, ServiceNow owns change and CyberArk owns privileged access. The options I assessed include Amazon Q Developer in Teams or Slack, a Bedrock-based assistant, and EventBridge and Lambda calling the Harness, TFE and ServiceNow APIs."},{"id":"work/state-street-vm-factory-image-bakery#outcome","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#outcome","section":"Outcome","text":"- A VM factory with one orchestrated flow, replacing six separate steps across four tools. - An image bakery producing a hardened, versioned golden image on the patch cycle, pinned by Terraform. - Readiness gates and per-VM evidence, so status is a record rather than a round of follow-up messages. - Security onboarding moved ahead of the build window, with no change to the controls themselves. - The manual application install templated like the others. - VM build time cut from about 30 minutes to 2–3 minutes. The baseline, agents and tools are already in the image, so a build only provisions, configures and installs what is specific to the VM. - Less complexity per build: one trigger and one status instead of six separate runs, and gates instead of reruns. The factory lines up with the Terraform Enterprise split: same templates, same controls, same readiness reporting."},{"id":"work/state-street-vm-factory-image-bakery#what-id-do-next","title":"VM factory & image bakery: VM builds cut from 30 minutes to 2–3","url":"/work/state-street-vm-factory-image-bakery/#what-id-do-next","section":"What I'd do next","text":"- Put the numbers on a dashboard. Build time and first-run success per wave, on a dashboard the leadership team already reads. - Make the golden image a product. Give it release notes, a CVE scan gate and a deprecation window per version, so app teams can plan upgrades. - Build the DR side from the same image. Then every patch-cycle release also refreshes the recovery estate."},{"id":"work/planhub-aws-platform","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/","section":"Summary","text":"PlanHub: For two years I was PlanHub's freelance SRE and platform engineer: I owned the AWS platform in Terraform, ran the developer platform (QA/UAT/Prod delivery with Boto3 blue/green cut-overs across 5 service tiers), kept production reliable, moved routine operations onto 7 EventBridge-scheduled Lambda jobs and closed security and compliance gaps, including 39 SSH keys moved into 1Password. SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases. Client: PlanHub (Construction tech (preconstruction SaaS)), as a freelance engagement, Jun 2023 – Jul 2025. Role: Site Reliability & Platform Engineer (freelance, 2 years 1 month). 5 service tiers on blue/green deployment; 7 EventBridge-scheduled Lambda jobs; 39 SSH keys migrated to 1Password; 3 pipeline environments: QA, UAT, Prod. Stack: Terraform, VPC, RDS PostgreSQL, ALB, Route53, ACM, ECS Fargate, ECR, CloudWatch, CodePipeline, CodeBuild, CodeDeploy, GitHub, Python (Boto3), EventBridge, Lambda, Fivetran, Redshift, QuickSight, 1Password, ClamAV, Slack."},{"id":"work/planhub-aws-platform#context","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#context","section":"Context","text":"PlanHub is a US preconstruction marketplace: general contractors use it to find bidders and manage bid coverage, subcontractors to find projects and prepare bids, and suppliers to reach the contractors pricing work. Contractors rely on it while they are actively bidding, so downtime or a bad release lands on someone's deadline. From June 2023 to July 2025 I was PlanHub's freelance site reliability and platform engineer. I owned the AWS platform end to end: the network and data tier, the developer platform that ships the product, the scheduled jobs that keep it tidy, the analytics feed, and security and compliance. The brief was two things at once: keep the developer platform moving for the engineering team, and keep production reliable for the contractors using it."},{"id":"work/planhub-aws-platform#constraints","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#constraints","section":"Constraints","text":"- Production traffic during releases. A SaaS product used by customers cannot take a maintenance window for every deploy, so cut-overs had to be zero-downtime. - A developer platform, not just infrastructure. Engineers needed QA, UAT and Prod environments they could trust and a release path they didn't have to think about. - Customer data with compliance obligations. Encryption, IAM and data handling had to meet HIPAA and GDPR expectations. - Several service tiers, one release process. Each of the 5 tiers needed the same deployment behaviour, not five hand-tuned variants. - Three environments that must stay alike. QA, UAT and Prod are only useful if what passes in one predicts what happens in the next. - Analytics without exposing data. Reporting had to reach the warehouse over private connectivity rather than a public endpoint."},{"id":"work/planhub-aws-platform#what-i-did","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#what-i-did","section":"What I did","text":"1. Multi-tier AWS infrastructure in Terraform. I designed the VPC, RDS PostgreSQL with read replicas, an Application Load Balancer, NAT Gateway, Route53 and ACM certificates, all as code, and ran the containerised services on ECS Fargate with ECR and CloudWatch log routing. 2. QA/UAT/Prod CI/CD. I built the delivery path on CodePipeline, CodeBuild and CodeDeploy with GitHub as the source, and added Slack notifications so release status reached the team without anyone watching a console. 3. Blue/green deployment automation. I wrote the cut-over logic in Python with Boto3 and applied it across all 5 service tiers. It manages ALB listener rules and the DNS cut-over, so traffic moves to the new environment only when it is ready. 4. Event-driven operations. I moved routine production chores onto 7 EventBridge schedules driving Lambda functions for archival, cleanup and push notifications. 5. Analytics pipeline. I architected a Fivetran to Redshift pipeline and set up private VPC connectivity for QuickSight, so dashboards read from the warehouse without a public path. 6. Security and compliance. I put HIPAA- and GDPR-aligned encryption, IAM controls and data-handling guardrails in place, migrated 39 SSH keys into 1Password and deployed ClamAV scanning across the environment."},{"id":"work/planhub-aws-platform#key-decisions","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Blue/green over in-place deploys Switching ALB listener rules and DNS gives an instant, well-understood rollback: point traffic back at the old environment. Two environments run side by side during a release, which costs more for that window. The same Boto3 cut-over automation for all 5 tiers Shared automation means a fix or improvement lands everywhere at once and every tier behaves the same on release day. The automation has to stay generic enough for every tier, which takes discipline as tiers diverge. AWS-native pipeline tooling CodePipeline, CodeBuild and CodeDeploy sit inside the same account boundary and IAM model as the workloads they deploy. Less portable than a cloud-agnostic CI system. EventBridge and Lambda for scheduled jobs Schedules become visible, versioned resources rather than cron entries on a server someone has to keep alive. Each job needs its own packaging, permissions and failure handling. Private QuickSight connectivity Keeps the reporting path to Redshift off the public internet. More networking to design and maintain than a public endpoint. SSH keys in a shared vault 39 keys in 1Password gives one place to see, rotate and revoke access. Engineers change how they fetch keys, which needs a short adjustment period. Why blue/green at the load balancer The cut-over lives at the ALB and in DNS rather than inside the application."},{"id":"work/planhub-aws-platform#key-decisions-2","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#key-decisions","section":"Key decisions","text":"That keeps the release mechanism independent of what each tier runs, which is what made it practical to apply the same automation to all 5 tiers. It also means the rollback path is exercised on every release, so it is not a procedure anyone has to remember under pressure. Why schedules as code Archival, cleanup and push-notification jobs are easy to forget until they stop running. Putting all 7 on EventBridge makes them part of the platform definition: they can be reviewed, deployed per environment and reasoned about like any other resource."},{"id":"work/planhub-aws-platform#outcome","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#outcome","section":"Outcome","text":"- A multi-tier AWS platform defined in Terraform, from VPC to database replicas to certificates. - A QA/UAT/Prod pipeline on CodePipeline with Slack release notifications. - Zero-downtime blue/green releases across 5 service tiers with the same Boto3 cut-over automation. - 7 EventBridge-scheduled Lambda jobs handling archival, cleanup and push notifications. - A Fivetran to Redshift pipeline with private QuickSight connectivity. - 39 SSH keys moved into 1Password, ClamAV scanning in place, and HIPAA- and GDPR-aligned controls on customer data. - Two years of keeping the developer platform moving and production reliable for a product contractors depend on while they bid."},{"id":"work/planhub-aws-platform#what-id-do-next","title":"SRE & platform engineering for a construction-tech SaaS: AWS on Terraform, zero-downtime releases","url":"/work/planhub-aws-platform/#what-id-do-next","section":"What I'd do next","text":"- Retire SSH where possible. With keys centralised, the next step is to reduce how many are needed at all, for example by moving interactive access to AWS Systems Manager Session Manager. - Automate the cut-over decision. Tie the blue/green switch to health checks and error-rate alarms so a bad release rolls back without a human in the loop. - Treat the scheduled jobs as one service. Give all 7 EventBridge jobs a shared SLO and dashboard, so a missed run is as visible as a failed deploy."},{"id":"work/five-below-azure-landing-zone-audit","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/","section":"Summary","text":"Five Below: I audited a retailer's Azure landing zone across Terraform, Well-Architected and CIS controls and runtime posture, then turned the findings into a versioned remediation roadmap that cut critical findings by 75% and identified $47K a year in savings. Azure landing zone audit, remediation & AKS modernisation. Client: Five Below (Retail), delivered via Ensono, 2022 – present. Role: Principal Consultant, DevOps (audit lead). $47K annual cloud savings identified; 75% reduction in critical findings; 8.0 / 6.6 WAF score, static vs runtime; v1–v5 audit report iterations. Stack: Terraform, Azure Well-Architected Framework, CIS Benchmarks, AKS, NGINX ingress, AKS app routing add-on, GitHub Actions."},{"id":"work/five-below-azure-landing-zone-audit#context","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#context","section":"Context","text":"Five Below runs its workloads on an Azure landing zone defined in Terraform. Like most landing zones a few years in, the code described one platform and the subscriptions held a slightly different one. The ask was an independent audit: how close is the estate to Microsoft's Well-Architected Framework (WAF) and the CIS benchmarks, where is money being wasted, and what should be fixed first. A second thread arrived during the engagement. The AKS clusters exposed workloads through NGINX-based ingress, and that ingress path was being retired on AKS in favour of the managed application routing add-on, with a November 2026 cutoff. The client needed that change scoped and priced before it became an outage."},{"id":"work/five-below-azure-landing-zone-audit#constraints","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#constraints","section":"Constraints","text":"- Production estate. The audit had to be read-only. Nothing could change in the subscriptions while it ran. - Two sources of truth. Terraform shows intent; the portal shows reality. A review of either alone would mislead. - A findings list nobody can act on is worthless. The output had to be ordered by risk and effort so the platform team could plan sprints against it. - A fixed external date for the ingress retirement, independent of the audit timeline."},{"id":"work/five-below-azure-landing-zone-audit#what-i-did","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#what-i-did","section":"What I did","text":"1. Static review of the Terraform IaC. I analysed the landing-zone Terraform and scored the design it describes against the WAF pillars. The design scored 8.0. 2. Runtime assessment of the live estate. I scored the same pillars against what was actually deployed. The runtime score was 6.6. The gap between the two numbers turned out to be the most useful finding of the audit. 3. CIS benchmark validation of the deployed resources, so security findings mapped to a recognised control rather than to my opinion. 4. Cost review. I looked for right-sizing candidates, storage that belonged on a cheaper tier, and data with no lifecycle policy. Together these came to $47K in annual savings. 5. A versioned report. The audit went through five versions (v1 to v5). Keeping finding IDs stable across versions is what lets a report double as a progress tracker. 6. Remediation roadmap. I grouped findings into ordered waves with owners. Working through it cut critical findings by 75%. 7. AKS ingress retirement. I scoped and priced the move from NGINX ingress to the AKS application routing add-on ahead of the November 2026 cutoff."},{"id":"work/five-below-azure-landing-zone-audit#key-decisions","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Score static and runtime separately A single blended score hides drift. Two numbers (8.0 vs 6.6) show that the design is sound and the operation has slipped. Twice the scoring work, and a lower headline number in front of the client. Anchor security findings to CIS A named control is easier to accept, prioritise and re-test than a reviewer's judgement. Some real but non-benchmarked risks needed extra justification. Version the report instead of re-issuing it Stable finding IDs across v1 to v5 turned the report into a tracking tool and gave the client an audit trail. More document discipline from me on every revision. Separate the ingress retirement from general remediation It had a hard date and its own cost. Mixing it into the backlog would have hidden the deadline. Two workstreams to report on instead of one. Why the static/runtime gap matters When code scores higher than runtime, the usual causes are portal changes that never made it back to Terraform, resources created outside the pipeline, and policies assigned in audit mode that nobody reviews. Fixing those is mostly process: route changes through the pipeline and turn the right policies to deny. That is cheaper than redesigning the landing zone, which the 8.0 static score said it did not need."},{"id":"work/five-below-azure-landing-zone-audit#key-decisions-2","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#key-decisions","section":"Key decisions","text":"Pricing the ingress change The AKS workload template already pointed the way: the public, sanitised copy I keep of the AKS vending template removes the old Helm-based NGINX release from state with a Terraform removed block and relies on the App Routing add-on instead. Scoping the change meant inventorying every ingress, its annotations and TLS handling, then estimating the per-cluster effort to move it."},{"id":"work/five-below-azure-landing-zone-audit#outcome","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#outcome","section":"Outcome","text":"- Critical findings down 75% through the remediation roadmap. - $47K a year in savings identified through right-sizing, storage tiering and lifecycle management. - A baseline of 8.0 static / 6.6 runtime WAF scores the client can re-measure against. - The ingress retirement scoped and priced before the cutoff, as its own costed piece of work."},{"id":"work/five-below-azure-landing-zone-audit#what-id-do-next","title":"Azure landing zone audit, remediation & AKS modernisation","url":"/work/five-below-azure-landing-zone-audit/#what-id-do-next","section":"What I'd do next","text":"- Make the audit continuous. Most checks here can run on a schedule: policy compliance exports, drift detection with terraform plan against each subscription, and a cost report. Re-scoring every quarter is better than a one-off audit. - Close the drift loop. Move audit-mode policies that matter to deny once the backlog is clear, so the runtime score cannot fall behind the design again. - Track the gap, not just the score. The static-to-runtime difference is the metric I would put on the platform team's dashboard."},{"id":"work/credit-du-maroc-gitlab-upgrade","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/","section":"Summary","text":"Crédit du Maroc: As a GitLab Professional Services Engineer I am upgrading a bank's self-managed GitLab from 12.x towards a supported 19.x release, one required stop at a time: each hop runs on a copy of the live data and is promoted only on evidence. The work is in progress. Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate. Client: Crédit du Maroc (Banking), delivered via GitLab, Oct 2026 – present. Role: Professional Services Engineer, GitLab (hop execution). 12.x → 19.x upgrade path, in progress. Stack: GitLab Omnibus, Docker Compose, PostgreSQL, nginx, rsync, Bash, Python, GitLab Runner."},{"id":"work/credit-du-maroc-gitlab-upgrade#context","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#context","section":"Context","text":"Crédit du Maroc runs its CI/CD on self-managed GitLab: source code and pipelines for the bank's engineering teams. The goal of this phase is a supported 19.x release with no data loss. Later phases cover moving the platform to new infrastructure. GitLab cannot jump from 12 to 19. Each major version has required upgrade stops, database migrations that must finish before the next stop, and bundled PostgreSQL upgrades along the way. GitLab's Upgrade Path tool turned that into a long chain of hops for this instance. I deliver it on GitLab's Professional Services team with one other engineer: we run hops alternately from one shared runbook. Status: in progress. The instance is several major versions past GitLab 12, but the path to 19.x isn't finished. I won't call it finished until the last hop is validated."},{"id":"work/credit-du-maroc-gitlab-upgrade#constraints","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#constraints","section":"Constraints","text":"- Regulated change control. Every hop needs an approved change, a maintenance window, evidence and a rollback plan agreed before the window opens. - Controlled access. All work goes through the bank's privileged-access controls, so every command is prepared and reviewed before the window opens. - Downtime per hop. Every hop needs a maintenance window, and disk space has to cover a full working copy of the data. - Live CI. Runners keep asking for jobs. A pipeline that starts mid-upgrade fails or writes to a database that is being migrated. - Version-specific traps. PostgreSQL major upgrades, an OS C-library change that invalidates text indexes, OpenSSL 3, token expiry enforcement and stricter CI job-token defaults each land at a different stop."},{"id":"work/credit-du-maroc-gitlab-upgrade#what-i-did","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#what-i-did","section":"What I did","text":"1. Planned the path as hops and windows. I generated the required stops with GitLab's Upgrade Path tool and read the upgrade notes for every major version crossed. Each hop has its own work item listing its gate and risks: PostgreSQL checks at each new major, an OpenSSL 3 TLS test, and an audit of CI job-token allowlists before GitLab 18. Hops with heavy migrations get longer windows. 2. Copy, upgrade, then promote. GitLab runs from the Omnibus container image, so I designed each hop to upgrade a copy rather than the live data. We warm-sync the data while GitLab is still up, stop it, cold-sync and back up PostgreSQL, then start the next pinned version on the copy. Live data is only replaced once the copy passes validation, and the old data is kept as an archive until the next hop starts. 3. Blocked CI at the proxy. Before downtime, nginx returns 503 to the runner job-request endpoint, so no new job can start. Running jobs get a fixed time to finish before they are cancelled and recorded. The closing checklist removes the block and proves CI works again with a test pipeline. 4. Made background migrations the gate. A hop does not start until the previous hop's migrations, both legacy and batched, are at zero with nothing failed."},{"id":"work/credit-du-maroc-gitlab-upgrade#what-i-did-2","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#what-i-did","section":"What I did","text":"On one hop a batched migration was estimated to run far longer than any reasonable window. We promoted with it still running and made its completion the gate for the next hop, instead of stretching the window. 5. Diffed the data, not just the health checks. Scripts capture the same baseline before and after every hop: versions, service state, migration status, and counts of projects, users, repositories and pipelines. The window only closes when nothing is missing. On one hop the comparison flagged changed branch-protection settings, and we investigated before closing rather than waving it through. 6. Handled the database milestones separately. Bundled PostgreSQL upgrades are planned stops. At the hop where the base image changed the C library, an index integrity check found damaged indexes before any reindex ran, so the fix was targeted and verified. 7. Kept runners out of the critical path. I inventoried the runners rather than asking the bank to upgrade them at every hop. Upgrades are grouped into checkpoints at the last release of each major, and the inventory also helped the client tidy up unused runners. 8. Published the sanitised method. I wrote the generic version as a public playbook: hop runbook, pre-checks, PostgreSQL, runners, rollback, evidence and operator safety, plus a read-only evidence collector."},{"id":"work/credit-du-maroc-gitlab-upgrade#key-decisions","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Upgrade a copy, then promote Live data is untouched until validation passes. Rolling back is a matter of not promoting, which is faster and safer than a restore. Needs disk for a full copy and adds sync time to every window. Block runner job requests at nginx Stops new CI work cleanly without touching the configuration of every runner in the fleet. One more change to revert. It sits on the closing checklist so it can't be forgotten. Background migrations as the hop gate Starting a hop with migrations still running is the most common way to break a multi-hop upgrade. Some windows wait on GitLab, not on us, and the timeline has to absorb that. Before-and-after data diff on every hop Health checks show the service is up. A diff shows the data is still all there, and it answers audit questions directly. Every unexpected difference has to be explained before the window closes. Runner checkpoints per major version Runners tolerate small version gaps. Grouping upgrades saves the client an action every hop. The gap grows within a major version, so each checkpoint matters. Snapshot as last resort, not first The copy and the kept archive cover most failures. A VM snapshot covers the rest. More artefacts to manage, with explicit rules on what is deleted and when."},{"id":"work/credit-du-maroc-gitlab-upgrade#outcome","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#outcome","section":"Outcome","text":"- The instance is off GitLab 12 and several major versions along the path with no data loss, every hop inside an approved window and backed by before-and-after evidence. - Downtime has varied a lot from hop to hop. The longest windows came from migrations and investigation, not the package install. - A repeatable hop runbook that two engineers run the same way, refined after each hop. Fixes include always restoring the proxy configuration non-interactively, and checking only the configuration files nginx actually loads. - The public playbook captures the method without client detail. The upgrade is still in progress. Each of the riskier gates on the path (token expiry in 16, OpenSSL 3 in 17, job-token allowlists in 18) has its own checks in the plan."},{"id":"work/credit-du-maroc-gitlab-upgrade#what-id-do-next","title":"Multi-hop self-managed GitLab upgrade for a bank's CI/CD estate","url":"/work/credit-du-maroc-gitlab-upgrade/#what-id-do-next","section":"What I'd do next","text":"- Finish the path and re-check it. Re-run the Upgrade Path tool before the final hops, since an extra required stop means renumbering the plan. - Automate the gate. Turn the migration check, data diff and closing checklist into one script with a clear pass or fail, so the operator reads one verdict instead of several outputs. - Rehearse a post-promote rollback. Not promoting is cheap. Rolling back from the kept archive after a promotion is the path I would most like proven on a clone. - Stay current afterwards. Agree a cadence with the client to take each required stop as it ships, so the next upgrade is one hop, not another long chain of them."},{"id":"work/gitlab-ci-platform-templates","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/","section":"Summary","text":"Multiple engagements: I designed reusable GitLab CI templates that deploy to multiple clouds with short-lived OIDC tokens instead of stored keys and gate every merge request on SAST, DAST and secret detection, then made them part of the shared CI/CD standard the engineers I guide work to across engagements. Reusable GitLab CI platform templates with OIDC & security gates. Client: Multiple engagements (Cross-industry), delivered via Ensono, 2022 – present. Role: Principal Consultant, DevOps (template design & team lead). 3 clouds from one template library: AWS, Azure, GCP; 3 merge-request gates: SAST, DAST, secrets. Stack: GitLab CI, OIDC, SAST, DAST, Secret detection, Merge request pipelines."},{"id":"work/gitlab-ci-platform-templates#context","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#context","section":"Context","text":"Ensono runs several client programmes at once, and I'm the senior technical lead across them, setting the engineering standards the delivery teams work to. GitLab CI comes up again and again in those engagements. Without a shared baseline, every engagement re-solves the same problems: how the pipeline authenticates to the cloud, and where security scanning runs. The answers drift apart, and the differences are where the risk sits: a long-lived cloud key in a CI variable, a scanner that runs after the merge instead of before it, a deploy job any branch can trigger. I designed a set of reusable GitLab CI templates to make those answers the same everywhere: OIDC authentication for multi-cloud deployments, and SAST, DAST and secret detection gating every merge request. They became part of the common CI/CD, IaC, security-scanning and release standards I set for the team, and they were adopted across engagements."},{"id":"work/gitlab-ci-platform-templates#constraints","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#constraints","section":"Constraints","text":"- Client isolation. Templates can be shared; trust cannot. Each client's cloud accounts must trust only that client's pipelines. - No stored cloud credentials. A static key in a CI variable is a secret to leak, rotate and audit. The design had to remove it, not just protect it. - Security before merge. Findings are cheapest to fix while the change is still in review. A scan that runs after deployment is a report, not a gate. - Usable by the whole team. If a template is harder than writing the YAML by hand, people write the YAML by hand. - Multi-cloud. The same pipeline shape had to deploy to whichever cloud the client runs on."},{"id":"work/gitlab-ci-platform-templates#what-i-did","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#what-i-did","section":"What I did","text":"1. A template library, not copy-paste. In GitLab, reuse means include to pull shared job definitions into a project and extends to specialise them. I built the templates as security and deployment building blocks, so a client project's .gitlab-ci.yml is mostly includes plus a few variables. 2. OIDC for every cloud deployment. GitLab can issue a signed, short-lived ID token to a job through the id_tokens keyword. The cloud validates that token against GitLab's OIDC issuer and exchanges it for temporary credentials: a role assumed with web identity on AWS, a federated credential on Azure, Workload Identity Federation on GCP. The templates wrap that exchange, so deploy jobs authenticate the same way on every cloud and no cloud key sits in a CI variable. 3. Trust scoped by claims. The token carries claims such as the project path, the ref, whether the ref is protected and the target environment. The design point that matters most is that the cloud-side trust policy is where the security actually lives. Binding a production role to a protected branch or environment of one project means a feature branch, or another project on the same GitLab, cannot assume it. 4. MR-gated SAST and secret detection. Static analysis and secret detection run in the merge request pipeline."},{"id":"work/gitlab-ci-platform-templates#what-i-did-2","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#what-i-did","section":"What I did","text":"A failing gate fails the pipeline, and the merge waits for a green one. 5. DAST against a running deployment. DAST needs something to probe, so it runs against a deployed test instance of the change rather than against the source. 6. Adoption as a standard. I made the templates part of the team's shared CI/CD and security-scanning standards, so engineers on a new engagement have a known-good starting point instead of a blank file."},{"id":"work/gitlab-ci-platform-templates#key-decisions","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   OIDC federation instead of stored cloud keys Nothing long-lived to leak or rotate. Credentials expire with the job, and access is decided by claims the cloud can verify. A trust relationship to configure per cloud and per client, and a failed token exchange is harder to debug the first time than a bad key. Shared job logic, per-client trust How to deploy is generic and belongs in the template. Who may deploy where is client-specific and belongs in the client's cloud. Every new client needs its federation set up before the first deploy works. Keep secret detection even with OIDC OIDC removes the pipeline's keys, not the ones a developer pastes into a config file. False positives need a clear, reviewed way to be allow-listed. Gate at the merge request, not at deploy The author still has context, and the reviewer sees the finding next to the diff. Longer MR pipelines, and DAST needs an environment to run against. Why OIDC is the centre of the design Static keys fail in predictable ways. They get copied into more projects than intended, they outlive the person who created them, and rotating them breaks pipelines, so they rarely get rotated. With federation, the question \"can this job deploy to production?\" is answered by a trust policy that reads verified claims. That policy can be reviewed, versioned and audited in one place, which is a far better conversation to have with a client's security team than a list of CI variables."},{"id":"work/gitlab-ci-platform-templates#outcome","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#outcome","section":"Outcome","text":"- Reusable GitLab CI templates adopted across engagements, as part of the shared engineering standard I set across programmes. - Cloud deployments authenticated with short-lived OIDC tokens rather than stored keys. - SAST, DAST and secret detection as merge-request gates, so findings surface before code merges rather than after it ships. I don't have a single headline number for this piece of work. The measure that matters is adoption: engineers across different clients reaching for the same templates."},{"id":"work/gitlab-ci-platform-templates#what-id-do-next","title":"Reusable GitLab CI platform templates with OIDC & security gates","url":"/work/gitlab-ci-platform-templates/#what-id-do-next","section":"What I'd do next","text":"- Move to GitLab CI/CD components. Components and the CI/CD Catalog give templates typed inputs, released versions and discoverability, which plain include files lack. - Pin versions and bump them automatically. Consumers pin a released version and a bot opens the upgrade merge request, so fixes spread without anyone's pipeline changing silently. - Enforce the gates, don't just include them. A project can delete an included job. Where the GitLab tier allows it, I would enforce scans centrally through security policies, so opting out needs an explicit, recorded exception. - Measure it. Track time from a new project to its first green deploy, and the median time to fix an MR security finding. Those two numbers show whether the templates are helping or getting in the way."},{"id":"work/ado-to-harness-migration","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/","section":"Summary","text":"Mott MacDonald: I led the build-out of an Azure landing zone QA environment (deployment sequencing, a Terraform connectivity fix and the GitHub Actions architecture) and wrote the feasibility catalogue for moving Azure DevOps pipelines to Harness SaaS, ending in a 5-week phased plan. Azure DevOps → Harness migration & ALZ QA. Client: Mott MacDonald (Engineering & consultancy), delivered via Ensono, 2022 – present. Role: Principal Consultant, DevOps (ALZ QA lead & migration author). 5 weeks phased migration plan. Stack: Azure Landing Zone, Terraform, GitHub Actions, Azure DevOps, Harness."},{"id":"work/ado-to-harness-migration#context","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#context","section":"Context","text":"Mott MacDonald's Azure estate sits on an Azure Landing Zone (ALZ) built from Terraform modules. I worked on two threads in this engagement. The first was the ALZ QA environment. A landing zone QA environment is where changes to the platform itself (policy, networking, subscription structure) can be proven before they reach the environments that host real workloads. I led its build-out: deployment sequencing, fixing the Terraform connectivity module and designing the GitHub Actions pipeline architecture. The second was a feasibility study for moving Azure DevOps pipelines to Harness SaaS. The question was not \"can Harness run a pipeline?\" but \"what would it take to move these pipelines, in what order, and how long?\" I authored the migration catalogue that answers it."},{"id":"work/ado-to-harness-migration#constraints","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#constraints","section":"Constraints","text":"- Order matters in a landing zone. Governance, networking and the subscriptions that depend on them have to arrive in the right sequence. Deploy out of order and resources either fail on missing dependencies or, worse, land without the guardrails meant to govern them. - Connectivity sits under everything. Hub networking, peering, routing and DNS are shared by every layer above, so a fault in the connectivity module blocks the whole build. - QA must resemble production. A QA landing zone that differs structurally from production proves very little. - A feasibility study must survive real pipelines. A vendor feature list is not a plan. The catalogue had to say which pipelines move easily, which don't, and why. - No big bang. CI/CD is how every team ships. A migration has to keep delivery working while it happens."},{"id":"work/ado-to-harness-migration#what-i-did","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#what-i-did","section":"What I did","text":"ALZ QA environment 1. Deployment sequencing. I worked out the order in which landing-zone components deploy into QA, so each layer finds its dependencies already in place. 2. Terraform connectivity module. I debugged and fixed the connectivity module. Nothing that relies on the network can deploy until it works, so it was the critical path. 3. GitHub Actions pipeline architecture. The principle I designed around is that the pipeline should encode the deployment order rather than leave it in a runbook or in someone's head. The shape I favour for landing zones follows from that: a Terraform plan on every pull request for review, apply on merge, and layers that run in dependency order, each gated on the success of the one before. Azure DevOps → Harness SaaS feasibility 4. Assessment checklists. A per-pipeline checklist to inventory what each pipeline really depends on. What makes an Azure DevOps pipeline hard to move is rarely the build steps. It is the surroundings: service connections, variable groups and secrets, shared YAML templates, agent pools, environments with approvals, and triggers. 5. Complexity scoring. Each pipeline gets a score from its checklist, which turns \"how long will this take?\" into a sum and lets the work be ordered by risk. 6. Expression-syntax mapping."},{"id":"work/ado-to-harness-migration#what-i-did-2","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#what-i-did","section":"What I did","text":"The two platforms reference variables and parameters differently, and that is where hand migrations break quietly. I mapped Azure DevOps syntax to its Harness equivalents. 7. A 5-week phased execution plan. The phasing follows the scoring: foundations first, then low-complexity pipelines to prove the pattern, then the harder waves once the approach has been tested on cheaper cases. What the mapping has to cover A flavour of the syntax and concept gaps, as illustrative examples rather than the client's pipelines:  Azure DevOps Harness Note   $(myVar) macro variable Pipeline variables move into the pipeline or a template. ${{ parameters.env }} template parameter or a runtime input Compile-time templating becomes runtime expressions or inputs. $(Build.BuildId) Closest equivalent, but numbered per pipeline rather than organisation-wide. Secret from a variable group Referenced from Harness's secret manager or a connected vault. Service connection Connector Authentication is re-established, not copied. Agent pool Delegate or build infrastructure Where the work runs changes shape."},{"id":"work/ado-to-harness-migration#key-decisions","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Encode the deployment order in the pipeline Sequencing in a pipeline is repeatable. Sequencing in a runbook depends on who runs it. Longer end-to-end runs, and the pipeline has to change whenever the layering does. Score complexity per pipeline, not for the estate as a whole A per-pipeline score gives an estimate that can be added up, challenged and re-ordered. Assessment effort up front, before anything moves. Map expression syntax explicitly A copied $(var) reference doesn't fail the import; it just stops meaning what it did. Silent breakage is the costliest kind. A large, unglamorous table to maintain. Phase the migration by complexity Early waves prove the pattern on pipelines that are cheap to fix. Later waves benefit from what was learned. Teams run on both platforms for a while, and two systems need supporting."},{"id":"work/ado-to-harness-migration#outcome","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#outcome","section":"Outcome","text":"- ALZ QA environment built out, with its deployment sequenced, the Terraform connectivity module fixed and a GitHub Actions pipeline architecture in place. - A migration catalogue for Azure DevOps → Harness SaaS: assessment checklists, complexity scoring and expression-syntax mapping. - A 5-week phased execution plan ordered by that scoring. The migration work was a feasibility piece. Its output is the evidence and the plan, not a migrated estate."},{"id":"work/ado-to-harness-migration#what-id-do-next","title":"Azure DevOps → Harness migration & ALZ QA","url":"/work/ado-to-harness-migration/#what-id-do-next","section":"What I'd do next","text":"- Automate the inventory. Most checklist answers can be pulled from the Azure DevOps REST API and the pipeline YAML. A script that pre-fills the checklist and a first-pass score would make re-assessment cheap as pipelines change. - Turn the mapping into a converter. Apply the syntax map as rules that produce draft Harness YAML, so engineers review a diff rather than rewrite by hand. - Run the pilot on both platforms. Run a pilot pipeline in parallel and compare artefacts and deployment results before switching it off in Azure DevOps. - Make QA a gate, not a sandbox. Every change to landing-zone Terraform should pass through the QA environment automatically before it reaches production."},{"id":"work/gcc-kubernetes-platforms","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/","section":"Summary","text":"DU Telecom, Etisalat, RAK Bank, Dubai Municipality, PDO: On the ground in Dubai for three years and Oman for one, I built and ran Kubernetes platforms on GKE, EKS, AKS and Tanzu, self-hosted GitLab on Kubernetes with security-integrated pipelines for RAK Bank and DU Telecom, and the networking and streaming plumbing around them for five regulated GCC clients. Kubernetes & GitLab platforms for GCC telecom, banking and government. Client: DU Telecom, Etisalat, RAK Bank, Dubai Municipality, PDO (Telecom, banking & government (GCC)), delivered via Ozone (Huco FZCO), 2019 – 2022. Role: Site Reliability Engineer (on-site). 3 yrs on-site in Dubai; 1 yr on-site in Oman; 5 named GCC clients; 4 Kubernetes platforms: GKE, EKS, AKS, TKGS. Stack: GKE, EKS, AKS, Tanzu (TKGS), vSphere 7, GitLab (self-hosted), Istio, Harbor, Fluentd, Jaeger, Kasten, AWS Kinesis, Confluent Kafka, Private Link, VPC peering, IAM, Cloud NAT."},{"id":"work/gcc-kubernetes-platforms#context","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/#context","section":"Context","text":"From 2019 to 2022 I worked as a Site Reliability Engineer for Ozone (Huco FZCO), delivering on site in the GCC: three years in Dubai and one year in Oman. The client list was a cross-section of the region's regulated sectors: DU Telecom and Etisalat in telecom, RAK Bank in banking, Dubai Municipality in government, and Petroleum Development Oman (PDO) in energy. Each client arrived with a different cloud preference and a different starting point. Across those engagements, the work came back to the same core: build Kubernetes platforms the client can run in production, give their teams a delivery pipeline they control, and wire both into networks that a bank or a government security team will sign off."},{"id":"work/gcc-kubernetes-platforms#constraints","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/#constraints","section":"Constraints","text":"- Regulated clients. Banks, telecoms and government bodies care where their source code, images and pipelines live. A managed SaaS toolchain was not always an option. - No single cloud. The work spanned GCP, AWS, Azure and on-premises VMware. Patterns had to carry across GKE, EKS, AKS and Tanzu without pretending the four are the same. - Private by default. Clusters and data services needed controlled egress and private connectivity, not public endpoints. - On-site delivery. Being on the ground made me the person the client's team turned to when something broke, so whatever I built had to be operable by them."},{"id":"work/gcc-kubernetes-platforms#what-i-did","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/#what-i-did","section":"What I did","text":"1. Self-hosted GitLab on Kubernetes. For RAK Bank and DU Telecom I built GitLab running on Kubernetes, with security checks built into the pipelines end to end rather than added as a separate stage after delivery. Keeping it self-hosted kept code and pipelines inside the client's own environment. 2. Managed Kubernetes on three clouds. I deployed and operated clusters on GKE, EKS and AKS, with network policies to restrict pod-to-pod traffic and Cloud NAT for controlled outbound access. 3. Tanzu on vSphere 7 for Blockchain-as-a-Service. I built Tanzu Kubernetes Grid Service (TKGS) on vSphere 7 to host a Blockchain-as-a-Service platform, bringing Kubernetes to an on-premises VMware estate. 4. A common cloud-native layer. I ran Istio as the service mesh, Harbor as the container registry, Fluentd for logging, Jaeger for tracing and Kasten for Kubernetes backup and recovery, all in production. 5. Multi-cloud network security. I governed connectivity and access across AWS, Azure and GCP using Private Link, VPC peering and IAM. 6. Real-time data pipelines. I built streaming pipelines on AWS Kinesis and on Kafka in Confluent Cloud. 7. Standardised CI/CD. Alongside GitLab, I standardised delivery across Jenkins, GitHub, AWS CodePipeline and Azure Pipelines for multi-environment releases, because not every client team was on the same toolchain."},{"id":"work/gcc-kubernetes-platforms#key-decisions","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Self-host GitLab on Kubernetes for the bank and the telecom Regulated clients want source, pipelines and scan results on infrastructure they control, and running GitLab on Kubernetes reuses the platform we were already operating. We owned GitLab upgrades, storage and backups instead of a SaaS provider. Security checks inside the pipeline A check that runs on every pipeline is harder to skip than a review at the end. Longer pipelines and more findings for teams to triage. One tooling layer across clusters Istio, Harbor, Fluentd, Jaeger and Kasten on every cluster meant one way to route, store images, log, trace and restore, whichever cloud it ran on. Each component is another production system to patch and upgrade. Private connectivity over public endpoints Private Link, VPC peering and Cloud NAT keep traffic off the public internet and make egress auditable. More networking to design and debug, especially across clouds. TKGS for the on-premises blockchain platform The estate was vSphere 7; TKGS brought Kubernetes to it without moving the workload to a public cloud. Tanzu adds its own lifecycle on top of vSphere."},{"id":"work/gcc-kubernetes-platforms#outcome","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/#outcome","section":"Outcome","text":"- Kubernetes platforms in production on four foundations: GKE, EKS, AKS and Tanzu on vSphere 7. - Self-hosted GitLab on Kubernetes with security-integrated pipelines for RAK Bank and DU Telecom. - A shared production layer of Istio, Harbor, Fluentd, Jaeger and Kasten. - Real-time pipelines on Kinesis and Confluent Kafka, inside a network governed with Private Link, VPC peering and IAM. - Four years of on-site delivery, three in Dubai and one in Oman, across five named clients."},{"id":"work/gcc-kubernetes-platforms#what-id-do-next","title":"Kubernetes & GitLab platforms for GCC telecom, banking and government","url":"/work/gcc-kubernetes-platforms/#what-id-do-next","section":"What I'd do next","text":"- GitOps for cluster configuration. With the same tooling layer on every cluster, the obvious next step is to declare it once in Git and reconcile it everywhere, rather than maintaining it cluster by cluster. - Policy as code at admission. Network policies set the baseline; admission policies would stop non-compliant workloads before they are scheduled, which suits regulated clients. - Shared reliability targets. I would put service-level objectives on the platform itself, using the tracing and logging already in place, so the client's team can see when it is drifting before users do."},{"id":"work/eks-30000-site-migration","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/","section":"Summary","text":"Intuitive Technology Partners: I architected an Amazon EKS platform prototype designed to onboard 20 clients and migrate 30,000 websites, with capacity planning to keep costs under control and SignalFx monitoring so problems surfaced before customers saw them. EKS platform prototype for a 30,000-site hosting migration. Client: Intuitive Technology Partners (Cloud consulting (AWS)), delivered via Intuitive Technology Partners, 2018 – 2019. Role: DevOps Engineer (platform architecture). 30,000 websites in migration scope; 20 clients to onboard. Stack: Amazon EKS, Kubernetes, AWS, SignalFx, Capacity planning."},{"id":"work/eks-30000-site-migration#context","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/#context","section":"Context","text":"In 2018 I joined Intuitive Technology Partners as a DevOps engineer. The problem on my desk was scale. A large hosting estate had to move: 20 clients, 30,000 websites between them. The direction was Kubernetes on AWS, and Amazon EKS had only just become generally available. My job was to architect the platform prototype that would prove the approach and become the template for the migration."},{"id":"work/eks-30000-site-migration#constraints","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/#constraints","section":"Constraints","text":"- Volume, not complexity, was the hard part. Any one website is easy to run. Thirty thousand of them, owned by 20 different clients, is a capacity, isolation and operations problem. - Cost had to be designed in. At that density, small per-site inefficiencies multiply into a large monthly bill. Capacity planning was part of the brief, not a follow-up. - A young managed service. EKS was new. The prototype had to show the platform was safe to bet on, not just that it worked on a good day. - Operations had to see problems first. With that many sites, nobody can wait for a customer to report an outage."},{"id":"work/eks-30000-site-migration#what-i-did","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/#what-i-did","section":"What I did","text":"1. Architected the EKS platform prototype. I designed the cluster platform the migration would land on, shaped around onboarding many clients onto shared infrastructure rather than building one bespoke environment per customer. 2. Planned capacity for the full estate. I worked out the capacity needed to carry 30,000 websites, which drove both the platform's sizing and its cost profile. 3. Built cost control into the design. Capacity planning doubled as the cost model, so right-sizing was a design decision rather than a clean-up exercise after go-live. 4. Defined the client onboarding path. With 20 clients to bring across, onboarding had to be repeatable. Each client should follow the same route onto the platform. 5. Deployed SignalFx for real-time EKS monitoring. I set up custom dashboards and proactive alerting so the team saw cluster and workload problems as they developed."},{"id":"work/eks-30000-site-migration#key-decisions","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/#key-decisions","section":"Key decisions","text":"Decision Why Trade-off   Prototype first, then migrate Proves the platform and the operating model on a small slice before committing 30,000 sites to it Slower start than lifting everything at once   Shared platform for many clients One platform to patch, monitor and cost, instead of 20 Isolation and fair resource sharing must be designed, not assumed   Capacity planning as the cost model At this density, sizing is the bill More up-front modelling before anything is built   Real-time monitoring from day one At this scale, alerting has to catch problems before customers do Dashboards and alerts to build and tune alongside the platform"},{"id":"work/eks-30000-site-migration#outcome","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/#outcome","section":"Outcome","text":"- An Amazon EKS platform prototype designed to onboard 20 clients and migrate 30,000 websites. - A capacity plan that framed the platform's size and cost before the migration started. - SignalFx real-time monitoring with custom dashboards and proactive alerting on EKS. Much of how I work now traces back to this platform: plan capacity before building, treat cost as an architecture property, and make the platform observable from the start."},{"id":"work/eks-30000-site-migration#what-id-do-next","title":"EKS platform prototype for a 30,000-site hosting migration","url":"/work/eks-30000-site-migration/#what-id-do-next","section":"What I'd do next","text":"- Autoscale nodes on real demand. Today I would pair the capacity plan with automated node provisioning, so the platform follows real traffic instead of a forecast. - Make each tenant a code module. One reviewed module per client (namespace, quotas, network policy, ingress) would turn onboarding into a pull request. - Use OpenTelemetry. Exporting through an OpenTelemetry collector keeps dashboards and alerts portable across monitoring vendors."},{"id":"projects/talentlens","title":"TalentLens","url":"/projects/talentlens/","section":"Summary","text":"TalentLens: A resume-screening pipeline that scores candidates the way a hiring panel would: eleven specialist reviewers, a deliberation round and a weighted consensus, with an offline mode that needs no API key. Eleven persona agents score independently, adjust after seeing each other's findings, then reach a weighted consensus. Hybrid semantic match: TF-IDF 40%, Sentence-BERT 40%, Jaccard 20%, with a TF-IDF fallback when embeddings are unavailable. Heuristic mode runs the whole pipeline with no API key; an LLM only improves parsing. Local and CI DevSecOps gates: Ruff, MyPy, Bandit, pip-audit, Gitleaks, pytest. 79 pytest tests across 7 modules; 11 specialist agent personas; 6 weighted scoring dimensions; 3 deliberation rounds per candidate. Project: open-source ai, 2026, active. Stack: Python 3.11+, Streamlit, Plotly, Sentence-Transformers, scikit-learn, Typer, SQLite, OpenAI / Anthropic (optional), GitHub Actions, taskctl. Code: https://github.com/rakshith-ponnappa/TalentLens"},{"id":"projects/talentlens#the-problem","title":"TalentLens","url":"/projects/talentlens/#the-problem","section":"The problem","text":"Screening a stack of resumes against a job description is slow and inconsistent. Keyword matchers are fast but shallow: they can see \"AWS\" on a page and cannot tell whether the candidate designed a production platform or followed a tutorial. One reviewer has one lens. A real hiring panel works better because a security architect, an SRE and an HR manager each notice different things, then argue. I wanted a tool that copies the panel structure, explains every score it gives, and still works on a laptop with no API key."},{"id":"projects/talentlens#how-it-works","title":"TalentLens","url":"/projects/talentlens/#how-it-works","section":"How it works","text":"The input is a job description and a set of PDF or DOCX resumes. The output is a ranked list, per-agent evaluations, verification flags and an interview questionnaire. 1. JD analysis. jd_analyzer.py turns the job description into structured criteria: required and preferred skills, experience, education level and certifications. It uses an LLM if a key is configured and falls back to heuristics.py (regex and rule-based parsing) if not. 2. Resume parsing. resume_parser.py builds a candidate profile the same way, with the same fallback. 3. Verification. verifier.py orchestrates company checks against OpenCorporates, certification lookups against a bundled registry, LinkedIn profile signals, email MX lookups and employment timeline analysis, and rolls them into a trust score. 4. Scoring. scorer.py scores six dimensions with default weights of 35 (required skills), 25 (experience), 15 (preferred skills), 10 (education), 10 (certifications) and 5 (semantic match). The semantic dimension blends TF-IDF cosine (40%), Sentence-BERT cosine with all-MiniLM-L6-v2 (40%) and Jaccard word overlap (20%). 5. The panel. agents.py defines eleven agents, from Cloud Solutions Architect (14% weight) down to QA Architect and Product Owner (6% each). Round one: each scores the candidate from its own perspective. Round two: each agent reads the panel's output and adjusts."},{"id":"projects/talentlens#how-it-works-2","title":"TalentLens","url":"/projects/talentlens/#how-it-works","section":"How it works","text":"If Security scores below 40, every other agent takes a penalty; strong architecture lifts the cloud and ops agents; an agent more than 20 points from the panel average is pulled 15% of the way back. Round three is a weighted consensus with a grade and a recommendation. 6. Output. Rankings, a skill-gap analysis, a DOCX interview questionnaire built from gaps and agent concerns, and history persisted to SQLite. A Typer CLI and an eight-page Streamlit dashboard sit over the same pipeline."},{"id":"projects/talentlens#engineering-decisions","title":"TalentLens","url":"/projects/talentlens/#engineering-decisions","section":"Engineering decisions","text":"Deterministic agents, optional LLM. The panel agents are Python classes with explicit rules, not prompts. That was deliberate. A screening score has to be reproducible and explainable, and every deliberation adjustment is written to a discussion log with its reason (\"SRE flags ops immaturity\", \"Adjusting toward panel average\"). The LLM, when present, only improves parsing. The cost is that the agents are only as good as their rules, which I tuned for cloud and platform roles. Hybrid similarity instead of embeddings alone. SBERT catches paraphrase, TF-IDF rewards precise terminology, and Jaccard is a cheap sanity check. If sentence-transformers fails to import, the SBERT share falls back to TF-IDF rather than failing the run. I wrote the TF-IDF myself so the core path does not need scikit-learn. Bounded deliberation. Cross-agent adjustments are small (2 to 5 points) and the drag toward the mean is capped. Unbounded feedback between agents would make the consensus depend on evaluation order. Weights in configuration. Dimension weights come from .env (WEIGHT_) or dashboard sliders and must sum to 100. Agent weights live in agents.py. Quality gates I would expect from a team. taskctl run all runs Ruff, MyPy, Bandit, pip-audit and Gitleaks in parallel, then pytest, then an Allure report. CI runs the same stages on Python 3.11, 3.12 and 3.13 and builds the Docker image. Pre-commit hooks enforce conventional commits and block direct commits to main."},{"id":"projects/talentlens#results--evidence","title":"TalentLens","url":"/projects/talentlens/#results--evidence","section":"Results & evidence","text":"- 79 pytest tests across seven modules. I counted the test functions: 24 for the pipeline state machine, 13 for red-flag detection, 12 for candidate comparison, 9 for archetype classification, 8 for history persistence, 7 for export formats and 6 for JD quality. - The README's generated stats block reports a 100% pass rate and 25.5% line coverage. - The full pipeline runs offline in heuristic mode, which is how the CLI and dashboard can be tried without credentials. I have not benchmarked ranking quality against human panel decisions, so I make no accuracy claim."},{"id":"projects/talentlens#limitations--next-steps","title":"TalentLens","url":"/projects/talentlens/#limitations--next-steps","section":"Limitations & next steps","text":"- Coverage is low at about 26%. The tests cover the supporting modules (pipeline, red flags, comparison, history, export); the agent panel and scorer have no unit tests yet. That is the first thing I would fix. - Agent rules are domain-specific. The personas and weights assume AWS-leaning cloud and platform roles. Other roles need new personas. - Verification depends on public signals. OpenCorporates coverage and LinkedIn resolution are best-effort and can miss legitimate history. - Dashboard screenshots are still missing from the README, and older dashboard versions (dashboard.py, dashboard_v2.py) remain in the repo alongside dashboard_v3.py. - Next: a labelled evaluation set of synthetic resumes so ranking changes can be measured, and unit tests for every deliberation rule."},{"id":"projects/agentic-paper-trader","title":"agentic-paper-trader","url":"/projects/agentic-paper-trader/","section":"Summary","text":"agentic-paper-trader: A guard-railed multi-agent LLM paper trader: the model reasons, but votes, deterministic gates, hard caps and a kill switch sit between it and every order. Three independent TradingAgents runs per ticker; the median rating wins, so one hallucinated Buy cannot trade. Buys pass a deterministic gate: SPY above its 200-day average, no earnings within 4 days, top-half factor rank, FinBERT news sentiment. The LLM proposes, code disposes: sizing, caps, stops and order payloads are plain, unit-tested Python. A 15-minute stop-loss and take-profit monitor that has no LLM in its path at all. 23 offline pytest tests; 3 votes per ticker before any order; 5 independent checks in the buy gate; 0 live-trading endpoints in the code. Project: open-source ai, 2026, active. Stack: Python 3.11, TradingAgents (LangGraph), OpenAI-compatible SDK, pandas, yfinance, FinBERT (transformers), Alpaca paper API, macOS launchd + Keychain, pytest, GitHub Actions. Code: https://github.com/rakshith-ponnappa/agentic-paper-trader"},{"id":"projects/agentic-paper-trader#the-problem","title":"agentic-paper-trader","url":"/projects/agentic-paper-trader/#the-problem","section":"The problem","text":"LLM agents are persuasive and non-deterministic. Ask the same multi-agent framework about the same stock twice and you can get \"Buy\" and \"Hold\". That is fine for a research note and dangerous for anything with a side effect. I wanted a working, end-to-end example of the pattern I would want around any agent that acts in the world: let the model reason, then put voting, cheap independent checks, hard limits and an off switch between it and the action. Trading is a good test bed because the side effect is concrete and the feedback is measurable. I kept it strictly on paper: the code only talks to Alpaca's paper-trading API and has no live endpoint to switch to."},{"id":"projects/agentic-paper-trader#how-it-works","title":"agentic-paper-trader","url":"/projects/agentic-paper-trader/#how-it-works","section":"How it works","text":"The daily loop in autotrader.py runs in scheduled slots: 1. Kill switch. If a KILL file exists in $TA_HOME, the trader and the monitor exit immediately. 2. Screen. A 20-ticker watchlist is screened on price metrics and cooldowns, and at most three new picks go forward per day. 3. Analyse three times. Each pick goes through TradingAgents with market, social, news and fundamentals analysts, three separate times, against any OpenAI-compatible endpoint. 4. Vote. majority() takes the median of the three ratings on a Sell-to-Buy scale: two-of-three agreement wins and a three-way split resolves to the middle. 5. Gate. buy_gate() returns a list of reasons to block: market below its 200-day average, earnings within four days, a factor percentile (12-1 momentum, 63-day volatility and quality from ROE and margin) below 50%, FinBERT news sentiment below -0.3, or an \"avoid\" from an LLM persona check that reads the stock through value, growth-at-a-reasonable-price and risk-manager lenses. An empty list means buy. 6. Plan and place. Orders are sized against a capped total allocation: at most 10% per ticker, 25 orders per run, and no new buys once unrealised loss passes 15% of the allocation. Entries are limit orders at the analysed close plus 1% that expire at the close. 7. Monitor. Every 15 minutes monitor.py checks positions against stored stops (8% below entry by default). A stop-out sells everything and starts a five-day cooldown; a 15% gain sells half, once."},{"id":"projects/agentic-paper-trader#engineering-decisions","title":"agentic-paper-trader","url":"/projects/agentic-paper-trader/#engineering-decisions","section":"Engineering decisions","text":"Ensemble and gates instead of a better prompt. Prompt tuning does not remove variance. Voting over independent runs reduces it, and deterministic checks catch the bad timing that LLM analysts often talk themselves past, such as a bear regime or earnings week. The model never builds orders. The LLM's output is a rating and, optionally, a stop level that parse_stop() extracts. Everything that touches money is ordinary Python covered by tests. No LLM in the risk path. The monitor depends only on prices and saved state, so a model outage cannot stop it from protecting positions. Idempotency at the API boundary. Every order carries client_order_id = ta- - - . If Alpaca returns HTTP 422 for a duplicate, the trader fetches the existing order rather than placing a second one. A real run happens once per slot per day; reruns are dry. Measure the guardrails. A gate that looks sensible can still cost returns. gate_backtest.py replays the point-in-time gates (regime, earnings, price factors) over past decisions, and rescore.py re-scores decisions over 5, 10 and 20-day windows from prices alone. A scorecard feeds back into sizing: a rating with at least ten scored decisions and negative mean alpha against SPY gets half-size buys. Secrets stay out of the repo. Alpaca keys come from the environment or the macOS Keychain, and LLM settings from a shell file outside the repo."},{"id":"projects/agentic-paper-trader#results--evidence","title":"agentic-paper-trader","url":"/projects/agentic-paper-trader/#results--evidence","section":"Results & evidence","text":"- 23 pytest tests, all offline, with Alpaca, yfinance and the LLM mocked or never called. They cover order planning, allocation caps, cooldowns, idempotent retries, stop and take-profit decisions, voting and the buy gate. - CI runs the suite on GitHub Actions. - Example launchd schedules cover three daily slots plus the 15-minute monitor, and every run writes a JSON record and an HTML report. I deliberately publish no P&L figures. The project is about the control pattern, not a strategy claim, and paper fills are not evidence of a real edge."},{"id":"projects/agentic-paper-trader#limitations--next-steps","title":"agentic-paper-trader","url":"/projects/agentic-paper-trader/#limitations--next-steps","section":"Limitations & next steps","text":"- Not every gate can be backtested. FinBERT and the persona check need a news archive, and the vote needs reruns, so gate_backtest.py only replays the price-based checks. - The persona check is itself an LLM call. It sits inside the gate as one veto among several, but it is not deterministic. - Scheduling is macOS-specific today (launchd and Keychain). - Next: containerise it and run on Cloud Run Jobs or a Kubernetes CronJob, add OpenTelemetry traces with cost per decision, build an evaluation view of vote agreement and gate hit rates, and put sentiment behind a hosted endpoint with the same interface. Paper trading only, and not financial advice."},{"id":"projects/local-rag-agent-platform","title":"local-rag-agent-platform","url":"/projects/local-rag-agent-platform/","section":"Summary","text":"local-rag-agent-platform: A local-first retrieval service where every stage of the RAG pipeline is visible, swappable and measured: ingest, embed, store, search, and retrieval evals that run in CI on every push. Retrieval quality is a number, not a feeling: Hit@k, Precision@k, Recall@k and MRR on a labelled query set. A deterministic hashing embedder makes tests and evals reproducible offline; real Ollama embeddings are one flag away. Content-addressed chunk IDs make index rebuilds byte-for-byte reproducible, so eval labels stay valid. Typed failure modes: an unreachable LLM is a 502, an empty response a 500, an empty index a 503. 0.857 Hit@3, offline baseline; 0.810 MRR, offline baseline; 19 offline pytest tests; 14 labelled eval queries. Project: open-source ai, 2026, active. Stack: Python 3.11, FastAPI, Ollama, httpx, Docker, pytest, GitHub Actions. Code: https://github.com/rakshith-ponnappa/local-rag-agent-platform"},{"id":"projects/local-rag-agent-platform#the-problem","title":"local-rag-agent-platform","url":"/projects/local-rag-agent-platform/#the-problem","section":"The problem","text":"Most RAG demos skip the part that matters in production: knowing whether retrieval is any good. A team changes the chunk size or swaps the embedding model, eyeballs three answers, and calls it better. When something regresses there is no baseline to compare against. I built this to make every moving part of a RAG pipeline small, visible and testable before swapping in production components such as a managed vector database, hosted embeddings or a gateway. It needs no cloud keys."},{"id":"projects/local-rag-agent-platform#how-it-works","title":"local-rag-agent-platform","url":"/projects/local-rag-agent-platform/#how-it-works","section":"How it works","text":"The project has an offline pipeline and an online service, sharing one index. Offline: 1. rag_ingest loads .md and .txt files and splits them into fixed-size character windows with overlap (400 characters with 80 overlap for the sample corpus). Each chunk ID is the first 16 hex characters of a SHA-1 over the relative path, the chunk index and the chunk text. 2. index_corpus embeds the chunks and writes a JSON vector index. 3. eval_retrieval runs every labelled query in evals/retrieval_eval.json against the index and averages Hit@k, Precision@k, Recall@k and MRR. Online: a FastAPI app with three endpoints. GET /health returns status. POST /search embeds the query and returns the top-k chunks (1 to 20) with scores and sources, or 503 if the index is empty. POST /chat sends a prompt to Ollama's /api/generate through an async client. Embedders sit behind one Embedder protocol. HashingEmbedder hashes each token with SHA-1 into one of 256 buckets, counts, and L2-normalises, so it is deterministic and needs no model. OllamaEmbedder calls a local model such as nomic-embed-text. The vector store is a brute-force cosine scan persisted as JSON, which is fine for thousands of chunks. The Docker image runs as a non-root user and builds the sample index at image build time."},{"id":"projects/local-rag-agent-platform#engineering-decisions","title":"local-rag-agent-platform","url":"/projects/local-rag-agent-platform/#engineering-decisions","section":"Engineering decisions","text":"Evals before features. The eval was there from the start and CI re-runs it on every push. A retrieval change only counts as an improvement if the numbers move. The metrics are pure functions with their own unit tests, so the measuring stick is itself tested. A deterministic embedder for CI. Downloading an embedding model in CI is slow and makes results drift with model versions. The hashing embedder gives a stable baseline. It is a bag of hashed words, so it measures lexical overlap rather than meaning, but it is good enough to catch a chunking regression. Comparing embedders is the point of having a baseline. Reproducible chunk IDs. Labels in the eval set reference chunk IDs. Because IDs are derived from content and position, rebuilding with the same settings produces the same IDs, and the eval file records the build settings it was labelled against. Change the corpus or chunk size and the labels must be regenerated, which is stated in the file. Small, swappable parts. The embedder, store and LLM client each sit behind a narrow interface, so pgvector, Qdrant or Azure OpenAI can replace them without touching the API. Fail loudly. The LLM client raises typed errors that map to 502 and 500, so a broken dependency shows up in monitoring rather than as an empty answer."},{"id":"projects/local-rag-agent-platform#results--evidence","title":"local-rag-agent-platform","url":"/projects/local-rag-agent-platform/#results--evidence","section":"Results & evidence","text":"Baseline with the offline hashing embedder, k = 3, chunk 400 / overlap 80, over 14 labelled queries:  Hit@3 Precision@3 Recall@3 MRR   0.857 0.310 0.857 0.810  Precision is capped by the labels: 13 of the 14 queries have a single relevant chunk, so the best possible Precision@3 on this set is about 0.357. Read against that ceiling, 0.310 is roughly 87% of the maximum. 19 offline tests cover ingestion and chunking, the vector store, the metrics, eval loading and the API, with /chat against a mocked LLM and /search against a temporary index."},{"id":"projects/local-rag-agent-platform#limitations--next-steps","title":"local-rag-agent-platform","url":"/projects/local-rag-agent-platform/#limitations--next-steps","section":"Limitations & next steps","text":"- /chat is not retrieval-grounded yet. It is plain generation through Ollama today. The service can retrieve and it can generate, but it does not yet put retrieved chunks into the prompt. That is the top roadmap item: retrieve, build a prompt with citations, generate. - The corpus is small. Four self-written documents chunk into ten pieces. The baseline proves the harness works; it says little about retrieval at scale. - Brute-force search will not scale past a few thousand chunks, by design. - The baseline is lexical. I have not published numbers for the Ollama embedder yet. - Next: cross-encoder reranking and hybrid BM25 plus vector search, OpenTelemetry traces with token and latency metrics, a Helm chart with an Ollama sidecar or GPU node pool, and /search exposed as an MCP tool for agents."},{"id":"projects/agent-sandbox-conformance-kit","title":"agent-sandbox-conformance-kit","url":"/projects/agent-sandbox-conformance-kit/","section":"Summary","text":"agent-sandbox-conformance-kit: A black-box test suite that checks what an AI agent code sandbox actually does, not what its documentation says: lifecycle, filesystem, snapshots, egress policy, secret handling and quota edges. Fifteen vendor-neutral checks, including cloud metadata reachability and DNS as an exfiltration side channel. Any sandbox platform plugs in through two small Protocols; unsupported features become SKIP, never a false FAIL. Guaranteed teardown: try/finally per check, an atexit registry for failed kills, and SIGTERM turned into a clean exit. Markdown matrix plus JSON evidence, with secret canaries redacted before anything is written. 33 pytest tests (incl. parametrised cases); 15 conformance checks in the catalogue; 7 check categories; 0 runtime dependencies. Project: open-source ai, 2026, active. Stack: Python 3.11+ (stdlib only), typing.Protocol adapters, Docker CLI, pytest, GitHub Actions. Code: https://github.com/rakshith-ponnappa/agent-sandbox-conformance-kit"},{"id":"projects/agent-sandbox-conformance-kit#the-problem","title":"agent-sandbox-conformance-kit","url":"/projects/agent-sandbox-conformance-kit/#the-problem","section":"The problem","text":"AI coding agents run code that nobody reviewed: model output, a fresh dependency, or something planted through prompt injection. The sandbox is the only boundary between that code and the network, the cloud control plane, injected secrets and the bill. One reachable egress path can exfiltrate source code. If the cloud instance metadata endpoint answers, instance credentials may be one HTTP request away. A sandbox that survives kill() keeps running and keeps costing money. Vendors document what their sandbox should do. I wanted a way to check, from the outside, what it actually does, so that providers can be compared, regressions caught, and vendors handed reproducible evidence."},{"id":"projects/agent-sandbox-conformance-kit#how-it-works","title":"agent-sandbox-conformance-kit","url":"/projects/agent-sandbox-conformance-kit/#how-it-works","section":"How it works","text":"python -m sandbox_conformance run --provider hands the runner a provider adapter and an optional list of categories. The runner creates sandboxes through the adapter, executes each selected check against them, and writes a Markdown matrix and a JSON evidence file. Exit code 0 means no FAIL or ERROR. The catalogue has 15 checks in seven categories: - lifecycle: create and run with exit-code propagation, kill() stops execution, no leftovers after teardown. - filesystem: UTF-8 round-trip, and binary safety across all 256 byte values, NUL and CR/LF. - snapshot: restore() rolls back modified files and removes files created after the snapshot. - network: deny-all blocks TCP to IPs and hostnames, an allowlist permits only listed hosts, the metadata endpoint is unreachable even under the most permissive policy, and DNS fails under deny-all. - secrets: environment secrets are absent from ps output and from platform logs. - quota: N parallel creates either succeed or are cleanly refused, and every one is torn down. - optional: PTY support and an offline git clone. An adapter implements two Protocols from provider.py: a provider with create() (and optionally list_active()), and a sandbox with run, write_file, read_file, snapshot, restore, set_network_policy and an idempotent kill. Two adapters ship with the kit. fake is in-memory and deterministic, with behaviour flags such as metadata_reachable, env_in_ps and leak_on_kill that simulate specific failures. local-docker drives the Docker CLI as a reference baseline."},{"id":"projects/agent-sandbox-conformance-kit#engineering-decisions","title":"agent-sandbox-conformance-kit","url":"/projects/agent-sandbox-conformance-kit/#engineering-decisions","section":"Engineering decisions","text":"Four result states, not two. PASS, FAIL, SKIP and ERROR mean different things. A platform that does not offer snapshots raises UnsupportedFeature, and the check becomes SKIP. An adapter that throws unexpectedly, or a teardown that fails, becomes ERROR. Conflating those with FAIL would make the matrix useless for comparing vendors. Probes print explicit verdicts. Network probes are small Python scripts that print CONNECTED, BLOCKED: , RESOLVED or UNRESOLVED: . If the interpreter is missing, there is no verdict token and the result is SKIP (inconclusive) rather than a false PASS. Absence of a connection error is not evidence of a block. Teardown is not optional. Each check runs inside try/finally and kills every sandbox it created. Anything whose kill() fails stays in a registry drained again at interpreter exit, and the CLI converts SIGTERM into a normal exit so the same path runs. A conformance tool that leaks sandboxes would fail its own quota check. Redaction at the source. Secret canaries are replaced with [REDACTED] in all evidence, so a failing secrets check does not itself leak the secret into a report. Zero runtime dependencies. Pure standard library, so the kit can be dropped into any vendor's CI without a dependency review. Thin, honest adapters. The README asks adapter authors not to emulate policy client-side and to pass secrets the way production code would, never on a command line."},{"id":"projects/agent-sandbox-conformance-kit#results--evidence","title":"agent-sandbox-conformance-kit","url":"/projects/agent-sandbox-conformance-kit/#results--evidence","section":"Results & evidence","text":"- 33 pytest tests (25 test functions, one parametrised over nine failure modes). The parametrised test flips one fake behaviour at a time and asserts that exactly the matching check fails, which tests the checks themselves rather than just the plumbing. The Docker adapter's command construction is tested without a Docker engine. - Against the conformant fake: 13 PASS, 0 FAIL, 2 SKIP (PTY and git not offered). - Against the deliberately leaky fake: four FAILs with specific messages, for leftover sandboxes, reachable metadata, DNS resolving under deny-all and a secret visible in ps. - The local-docker baseline is not a hardened sandbox. On many cloud VMs the metadata endpoint is reachable from the bridge network, and the kit reports that correctly as a failure."},{"id":"projects/agent-sandbox-conformance-kit#limitations--next-steps","title":"agent-sandbox-conformance-kit","url":"/projects/agent-sandbox-conformance-kit/#limitations--next-steps","section":"Limitations & next steps","text":"- Early, v0.1. Two reference adapters; no commercial sandbox adapters are bundled, and I publish no vendor results. The README sets out a responsible-disclosure process: report privately first, allow a reasonable fix window (90 days is the common default), and never probe beyond the black-box check. - Egress coverage is TCP and DNS only. IPv6, raw UDP, ICMP, HTTP(S) proxies and DNS-over-HTTPS are on the roadmap. - No filesystem-escape or resource-exhaustion checks yet. Host mounts, /proc/1/root, symlink races, and CPU, memory, disk and PID limits are next, along with cross-tenant snapshot isolation, timeout enforcement, and signed reproducible reports."},{"id":"projects/vscode-lm-openai-gateway","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/","section":"Summary","text":"vscode-lm-openai-gateway: A single-file VS Code extension that exposes the editor's Language Model API as a loopback-only, token-protected, OpenAI-compatible endpoint, with tool calling and reasoning effort. OpenAI Chat Completions in, vscode.lm out: one 300-line file with no runtime dependencies. Function tools and tool_choice map onto the editor's model API, including multi-turn tool results. Security first: loopback bind, 256-bit bearer token in a 0600 file, constant-time comparison, no CORS, 20 MB body cap. Prompts and completions are never logged; only method, path, status, model and latency are. ~300 lines in a single extension.js; 0 runtime dependencies; 2 OpenAI endpoints implemented; 7 mapped OpenAI-style error codes. Project: open-source ai, 2026, active. Stack: JavaScript (Node.js), VS Code Extension API, vscode.lm, Node http + crypto, vsce, GitHub Actions. Code: https://github.com/rakshith-ponnappa/vscode-lm-openai-gateway"},{"id":"projects/vscode-lm-openai-gateway#the-problem","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/#the-problem","section":"The problem","text":"A lot of agent tooling speaks one dialect: OpenAI Chat Completions. The language models I already have inside VS Code are reachable only through the editor's own vscode.lm API. I wanted to point local tools (curl, the OpenAI SDK, agent frameworks such as TradingAgents) at those models during personal development without writing a bespoke client for each one. The hard part is not the translation. It is doing it without opening a hole: an unauthenticated local HTTP server that forwards prompts to a signed-in model is something any web page or local process could abuse."},{"id":"projects/vscode-lm-openai-gateway#how-it-works","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/#how-it-works","section":"How it works","text":"The extension activates on onStartupFinished. On first run it generates a token with crypto.randomBytes(32), writes it to ~/.copilot-lm-gateway/token with mode 0600 inside a 0700 directory, and starts a Node http server bound to the loopback interface (port 8787 by default). Two routes are implemented: - GET /v1/models lists chat models available through vscode.lm from the copilot vendor, with id, name, family and max_input_tokens. - POST /v1/chat/completions accepts the OpenAI request shape. model matches an id first, then a family. Messages in system, developer, user, assistant (with tool_calls) and tool roles are converted into vscode.lm messages. Function tools and tool_choice (auto, none, required or a named function) are passed through, and tool calls come back as message.tool_calls with finish_reason: \"tool_calls\". reasoning_effort can be set per request or by a setting. The extension calls sendRequest, iterates the response stream to collect every text and tool-call part, and returns a single chat.completion object. If the client disconnects, a cancellation token aborts the in-flight model request."},{"id":"projects/vscode-lm-openai-gateway#engineering-decisions","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/#engineering-decisions","section":"Engineering decisions","text":"Authenticate every route. Even /v1/models requires the bearer token. The comparison uses crypto.timingSafeEqual after a length check, so the token cannot be recovered by timing. Loopback only, no CORS. Binding to the loopback interface keeps other machines out. Sending no CORS headers keeps browser pages out, which matters more than it looks: a malicious page can otherwise make requests to localhost. The README is explicit that the trust boundary is the OS user account, and that the gateway must not be exposed through port forwarding, tunnels or reverse proxies. Bounded input. Bodies over 20 MB get a 413 and the socket is closed. Content-free logs. The output channel records method, path, status, model and latency. Prompts and completions never touch a log, so a shared screen or a support bundle does not leak them. Fit the model's constraints, not the client's. The stable vscode.lm API has no system role, so system and developer prompts become user messages. Consecutive same-role messages are merged because some models require strict user/assistant alternation, and that also puts parallel tool results in a single turn. OpenAI-shaped errors."},{"id":"projects/vscode-lm-openai-gateway#engineering-decisions-2","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/#engineering-decisions","section":"Engineering decisions","text":"Failures return {\"error\": {\"message\", \"type\"}} with 400 (malformed request or unsupported option such as streaming), 401 (bad token), 403 (model access not granted), 404 (unknown model or route), 413 (body too large), 429 (provider quota or rate limit) and 502 (other model errors), so standard SDK retry and error handling works unchanged. One file, zero dependencies. extension.js uses only Node built-ins and the VS Code API, which keeps the supply chain and the review surface small. CI syntax-checks it and packages a .vsix as a build artefact. Responsible use is part of the design. The README states that it is for personal, local development, that users must comply with their model provider's terms, including limits on automated or high-volume use, and that the project is not affiliated with GitHub or Microsoft."},{"id":"projects/vscode-lm-openai-gateway#results--evidence","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/#results--evidence","section":"Results & evidence","text":"- Works with curl and the OpenAI Python SDK, including tool calling with tool_choice=\"required\". The README carries runnable examples of both. - examples/ wires it up as the OpenAI-compatible backend for TradingAgents through environment variables only. - CI runs node --check and builds the .vsix on every push to main and every pull request. There is no automated test suite yet. I am stating that plainly rather than dressing the CI checks up as tests."},{"id":"projects/vscode-lm-openai-gateway#limitations--next-steps","title":"vscode-lm-openai-gateway","url":"/projects/vscode-lm-openai-gateway/#limitations--next-steps","section":"Limitations & next steps","text":"- No streaming. stream: true is rejected with a 400; output is collected and returned in one response. Server-sent events are the first roadmap item. - usage is always zero. Token counts are not reported yet; countTokens is the planned fix. - Text only, sampling parameters ignored. Image and audio parts are dropped, and temperature, max_tokens, stop and similar fields are not forwarded. - Copilot vendor only, and only two endpoints: no embeddings, legacy completions or Responses API. - VS Code must be running. With several windows open, the first one owns the port. - Next: SSE streaming, token usage, a configurable vendor filter, token rotation commands, and integration tests with @vscode/test-electron."},{"id":"projects/shorts-engine","title":"shorts-engine","url":"/projects/shorts-engine/","section":"Summary","text":"shorts-engine: An early-stage, guardrailed YouTube Shorts pipeline: trend discovery, clipping of own or rights-cleared video, Whisper captions, optional AI originals behind human review, and private uploads on a conservative ramp. Nothing is clipped unless the rights registry lists it; licensed sources without a written permission reference are refused. Duplicate guardrails: transcript shingle Jaccard, time overlap with earlier clips, and normalised title matching. AI originals carry the synthetic-media flag and wait in a human review queue; high-risk scripts are always held. Uploads are always private with a scheduled publish time, ramping from 1 to 3 a day. 18 offline pytest tests; 1 → 3 uploads per day, default ramp; 20–58 s highlight window length; −14 LUFS loudness target on renders. Project: open-source ai, 2026, active. Stack: Python 3.10+, YouTube Data API v3, Google OAuth, faster-whisper, OpenAI / Azure OpenAI, ffmpeg + libass, yt-dlp, SQLite, launchd / systemd, GitHub Actions. Code: https://github.com/rakshith-ponnappa/shorts-engine"},{"id":"projects/shorts-engine#the-problem","title":"shorts-engine","url":"/projects/shorts-engine/#the-problem","section":"The problem","text":"Automating short-form video is easy to do badly. The obvious version scrapes popular videos, cuts them up and re-uploads them at volume. That is copyright infringement and the fastest way to get a channel struck under YouTube's reused-content and spam policies. I wanted to see what an automated pipeline looks like when the guardrails are the design, not an afterthought: it should only touch content it has rights to, refuse near-duplicates, disclose synthetic media, put a human in front of AI-generated scripts, and default to low volume."},{"id":"projects/shorts-engine#how-it-works","title":"shorts-engine","url":"/projects/shorts-engine/#how-it-works","section":"How it works","text":"shorts-engine run executes one day of the pipeline; daemon repeats it until the campaign ends. 1. Trends. trends.py finds the most-viewed recent uploads for niche keywords through the YouTube Data API, drops off-topic hits, and scores keywords by view velocity, with extra weight from the channel's own top performers. 2. Sources. sources.py only uses what the rights registry in config.yaml lists: own videos dropped in data/inbox/, or licensed URLs downloaded with yt-dlp that carry a recorded permission_ref. 3. Highlights. faster-whisper produces a transcript with word timings. highlights.py cuts 20 to 58-second windows and scores them for hook, pace and trend match. An optional LLM pass re-ranks them and writes the title, hook, commentary and tags. 4. AI originals. With an LLM configured, original.py scripts a short on a trending topic, narrates it with TTS and lays captions over owned b-roll. 5. Guardrails. guardrails.py checks rights and, with the default thresholds, rejects clips that overlap an earlier clip from the same source by more than 50%, rejects transcripts above 0.6 Jaccard similarity on 3-word shingles, and rejects duplicate normalised titles. 6. Render. ffmpeg produces 1080×1920 output with a blurred fill background, word-by-word highlighted ASS captions, hook text, a credit line, a spoken commentary intro and audio normalised to −14 LUFS. 7. Review and upload. AI originals wait until shorts-engine review --approve . Uploads are resumable, always private with a publishAt time spread across the publish window, and stop cleanly when the API quota is hit. 8. Stats. Views, likes and comments for the last 14 days of uploads feed back into trend scoring."},{"id":"projects/shorts-engine#engineering-decisions","title":"shorts-engine","url":"/projects/shorts-engine/#engineering-decisions","section":"Engineering decisions","text":"Rights as data, enforced in code. The registry is configuration and the check is code. A licensed source with no permission reference is refused rather than warned about, because a warning in a daemon log is not a control. Cheap, explainable duplicate detection. Shingle Jaccard and interval overlap are simple and fast, and when they reject a clip I can say exactly why. Embeddings would catch more paraphrase, but a guardrail that cannot explain itself is hard to tune. Volume is the last lever, not the first. The ramp grows linearly from 1 to 3 uploads a day over 14 days, and plan prints the day-by-day quota before anything runs. Each source yields at most a configured number of clips per day and earlier clips are never reused. The README says it bluntly: more sources raise volume, turning off guardrails does not. Identity checks on every batch. auth refuses to log in as any channel other than the configured channel_id, and every upload batch re-checks it, so a wrong browser session cannot publish to the wrong channel. Degrade without an LLM. Without one, clips still work with heuristic scoring and the first sentence as the title. AI originals and spoken commentary are skipped rather than faked. Operational honesty about Google. The README documents the two restrictions that will bite: uploads from unaudited API projects stay private, and refresh tokens for \"Testing\" OAuth apps expire after seven days."},{"id":"projects/shorts-engine#results--evidence","title":"shorts-engine","url":"/projects/shorts-engine/#results--evidence","section":"Results & evidence","text":"- 18 offline pytest tests (16 functions, one parametrised over three degenerate ramp shapes). They cover the duplicate guardrail, the rights registry, the ramp and quota maths, publish-slot spacing, config validation, captions, highlight scoring and trend aggregation. Heavy optional dependencies are skipped with importorskip, and render tests skip without a libass-enabled ffmpeg. - CI runs the suite on Python 3.10, 3.11 and 3.12. - doctor checks every setup step, and run --dry-run renders and shows the schedule without uploading. I report no channel performance numbers; the project is about the pipeline and its controls."},{"id":"projects/shorts-engine#limitations--next-steps","title":"shorts-engine","url":"/projects/shorts-engine/#limitations--next-steps","section":"Limitations & next steps","text":"- Early-stage. It works end-to-end for a single owner and channel, but interfaces and config keys may change. The README says so in a badge at the top. - No pipeline integration tests yet. The tests cover the logic units; the orchestration in pipeline.py is not tested against mocked YouTube and LLM clients. - Guardrails do not guarantee policy compliance. They reduce risk; the operator still has to read and follow YouTube's policies. - Clips skip human review by default; only AI originals are held. - Next: integration tests, licence metadata with expiry and scope, a local review UI, optional review for clips, a policy lint for titles and descriptions, and a container image with ffmpeg and libass."},{"id":"projects/azure-landing-zone-terraform","title":"azure-landing-zone-terraform","url":"/projects/azure-landing-zone-terraform/","section":"Summary","text":"azure-landing-zone-terraform: An opinionated, CAF-aligned Azure landing zone in small Terraform modules: management groups and policy, hub-spoke connectivity, subscription vending and a private AKS spoke, with policy-as-code checks in CI. A new landing zone is a pull request with a tfvars file, not a portal ticket. Spoke stacks create both sides of hub peering through an aliased provider, without Contributor on the hub. Private AKS with CNI Overlay and Cilium, firewall-forced egress and Entra ID-only access. 72 input validation rules make bad CIDRs, SKUs and privileged roles fail at plan, not halfway through apply. 8 composable Terraform modules; 72 variable validation rules; 4 CI jobs: fmt, validate, tflint, checkov; 0 pipeline secrets (OIDC only). Project: open-source platform, 2026, active. Stack: Terraform >= 1.6, azurerm ~> 4.65, Azure Policy, Azure Firewall, AKS (CNI Overlay + Cilium), Entra ID workload identity, GitHub Actions OIDC, TFLint, Checkov. Code: https://github.com/rakshith-ponnappa/azure-landing-zone-terraform"},{"id":"projects/azure-landing-zone-terraform#the-problem","title":"azure-landing-zone-terraform","url":"/projects/azure-landing-zone-terraform/#the-problem","section":"The problem","text":"Every enterprise Azure platform I have built needed the same skeleton: a management-group hierarchy with guardrail policy, a hub network that owns egress and DNS, a repeatable way to hand application teams a subscription, and a secure default for Kubernetes. The reference implementations that exist are thorough, but they are large enough that a team adopting them often cannot say what half the code does. I wanted the same patterns in modules small enough to read in one sitting, with every name, ID and address a placeholder so the repo can be public."},{"id":"projects/azure-landing-zone-terraform#how-it-works","title":"azure-landing-zone-terraform","url":"/projects/azure-landing-zone-terraform/#how-it-works","section":"How it works","text":"Two example stacks, deployed in order. examples/platform composes four modules: - governance builds the hierarchy (root, then Platform with Management, Connectivity and Identity; Landing zones with Corp and Online; Sandbox; Decommissioned) and assigns built-in policies: allowed locations, required and inherited resource-group tags, and no public IPs on NICs. - management creates the central Log Analytics workspace, an optional Automation account, and a diagnostic-settings helper. - connectivity builds the hub VNet, Azure Firewall with a DNS proxy and an AKS egress rule collection, Bastion, central private DNS zones and the hub side of peering. - identity creates a user-assigned identity with federated credentials for GitHub Actions OIDC, plus RBAC. examples/landing-zone-aks runs once per application. It takes the platform outputs (hub VNet ID, firewall IP, private DNS zone ID, workspace ID) as inputs and composes: - lz-vending: optional subscription alias and management-group placement, resource groups, a spoke VNet with NSGs, a route table sending 0.0.0.0/0 to the firewall, peering in both directions, a subscription spend alert, and app-team RBAC. - aks-spoke: a private cluster with CNI Overlay and Cilium, user-defined-route egress through the firewall, local accounts disabled, workload identity, the Azure Policy add-on, Container Insights and control-plane diagnostics including kube-audit-admin. naming and tagging give every module the CAF naming convention and the mandatory tag set."},{"id":"projects/azure-landing-zone-terraform#engineering-decisions","title":"azure-landing-zone-terraform","url":"/projects/azure-landing-zone-terraform/#engineering-decisions","section":"Engineering decisions","text":"Hub-spoke rather than Virtual WAN. It gives explicit control over firewall, DNS and routing, costs less for a handful of regions, and is easier to reason about. Virtual WAN is on the roadmap for large multi-region estates. Vending as code. A landing zone is a reviewed pull request. The guardrails (no Owner for app teams, a default route to the firewall, a spend alert) are code paths, not checklist items a human might skip. Two providers for peering. lz-vending declares an azurerm.hub provider alias, so the spoke stack can create both sides of the peering without ever being given Contributor on the hub. Overlay networking for AKS. Pods do not consume VNet addresses, so spokes stay /22-sized and IP planning stays sane across many landing zones. Built-in policies first. Built-in definitions need no maintenance. Custom ones are only worth it when nothing built in fits. Fail at plan, not apply. There are 72 validation blocks across the module variables, covering CIDRs, SKUs, reserved subnet names and privileged roles. App-team role assignments reject Owner, User Access Administrator and RBAC Administrator outright. A half-applied landing zone is far more expensive to clean up than a failed plan. No secrets anywhere. CI authenticates with OIDC federated credentials, and remote state uses Entra ID auth with shared keys disabled."},{"id":"projects/azure-landing-zone-terraform#results--evidence","title":"azure-landing-zone-terraform","url":"/projects/azure-landing-zone-terraform/#results--evidence","section":"Results & evidence","text":"- 8 modules and 2 example stacks, roughly 3,000 lines of HCL, each module with its own README. - CI on every push and pull request: terraform fmt -check -recursive, init -backend=false plus validate for each example, TFLint with the azurerm ruleset, and a Checkov policy-as-code scan with results in the job summary. - A commented plan job shows the exact azure/login OIDC wiring for connecting the repo to a real tenant. - The security baseline is visible in code: private API server, no NIC public IPs by policy, Bastion-only admin access, firewall threat intelligence set to Deny, and central diagnostics for the firewall, hub and AKS control plane. The patterns come from enterprise platforms I have built; this repository distils them with placeholder values, and its CI validates the code without connecting to a tenant."},{"id":"projects/azure-landing-zone-terraform#limitations--next-steps","title":"azure-landing-zone-terraform","url":"/projects/azure-landing-zone-terraform/#limitations--next-steps","section":"Limitations & next steps","text":"- No module tests. Validation is static (fmt, validate, lint, Checkov). Terratest or terraform test suites are the most important gap. - Checkov is soft-fail, so findings are reported rather than blocking. - Single connectivity model. No Virtual WAN option yet. - Security tooling stops at the platform layer. Defender for Cloud plans, a Sentinel workspace option and an AKS policy initiative (pod security baseline, allowed registries) are on the roadmap. - Next: an option to swap modules for Azure Verified Modules where they fit."},{"id":"projects/gitlab-omnibus-upgrade-playbook","title":"gitlab-omnibus-upgrade-playbook","url":"/projects/gitlab-omnibus-upgrade-playbook/","section":"Summary","text":"gitlab-omnibus-upgrade-playbook: A field-tested runbook for multi-hop self-managed GitLab Omnibus upgrades: plan the required stops, gate every hop on evidence, and always keep a tested way back. Background migrations, not the package install, are the gate between hops. A read-only evidence collector runs the same 11 checks before and after every hop, so diffs answer audit questions. Rollback decision points and a time box are agreed in the change request before the window opens. Written for regulated estates with strict, audited access and approved change windows. 12.x → 19.x major-version span of the case study; 8 runbook chapters; 11 evidence checks per hop; 2 copy-and-fill templates. Project: open-source platform, 2026, active. Stack: GitLab Omnibus (EE), Bundled PostgreSQL, Bash, gitlab-rake / gitlab-rails, ShellCheck, markdownlint, GitHub Actions. Code: https://github.com/rakshith-ponnappa/gitlab-omnibus-upgrade-playbook"},{"id":"projects/gitlab-omnibus-upgrade-playbook#the-problem","title":"gitlab-omnibus-upgrade-playbook","url":"/projects/gitlab-omnibus-upgrade-playbook/#the-problem","section":"The problem","text":"Self-managed GitLab instances drift. A single-node Omnibus install that nobody wanted to touch ends up several major versions behind, and at that point you cannot jump to the current release. Each major version has required upgrade stops. Background database migrations must finish before the next hop. The bundled PostgreSQL gets upgraded along the way. Skip any of that and you risk a broken instance with source code, CI variables and runner tokens inside it. The case behind this playbook made it harder. It was a regulated financial-services customer on 12.x with strict, audited access. The target was a supported 19.x release with no data loss, every hop inside an approved maintenance window, and evidence for audit. I turned what I learned into a repeatable process."},{"id":"projects/gitlab-omnibus-upgrade-playbook#how-it-works","title":"gitlab-omnibus-upgrade-playbook","url":"/projects/gitlab-omnibus-upgrade-playbook/#how-it-works","section":"How it works","text":"The playbook is eight chapters, two templates and one script. 1. Plan the path. Generate the required stops with GitLab's Upgrade Path tool, then group them into maintenance windows of one to a few hops. Treat PostgreSQL and OS milestones as their own stops. 2. Pre-check. Run scripts/precheck-collect.sh before- . It writes one file per check into a timestamped folder: version manifest, gitlab:env:info, service status, gitlab:check SANITIZE=true, db:migrate:status, queued batched migrations, legacy background migrations, PostgreSQL version, disk, memory and OS release. Stop if anything fails or migrations are not at zero. 3. Back up. gitlab-backup create STRATEGY=copy, plus separate copies of gitlab-secrets.json and gitlab.rb, plus a VM snapshot before every window. 4. Install one pinned version. Never \"latest\" from a configured repository, which silently skips required stops. 5. Verify. Service status, gitlab:check, zero down migrations, the readiness endpoint, then smoke tests: local and LDAP sign-in, clone and push over HTTPS and SSH, a merge request and pipeline, and a runner picking up a job. 6. Gate. Query the batched-migration queue. Zero and nothing failed means collect after- evidence and continue. Still running means wait. Failed means retry, finalise or roll back. 7. Final validation once the last stop is done: runners, LDAP and integrations, then sign-off."},{"id":"projects/gitlab-omnibus-upgrade-playbook#engineering-decisions","title":"gitlab-omnibus-upgrade-playbook","url":"/projects/gitlab-omnibus-upgrade-playbook/#engineering-decisions","section":"Engineering decisions","text":"Background migrations are the real gate. The package install finishing feels like success, but starting the next hop with migrations still running is the most common way to break an upgrade. On some hops the wait was minutes; on others it was an hour or more. The runbook makes the queue count the explicit go/no-go. Evidence is the same shape every time. The collector is read-only, never aborts the whole run on one failed command, and prints a summary of down migrations and queued counts. Running it identically before and after each hop means a diff answers both \"what changed?\" and the auditor's questions. Rollback is decided before the window. In-place downgrades are not supported, so rollback means returning the whole instance to its pre-hop state. The options are ordered fastest first: VM snapshot, backup restore on the identical version with the saved secrets, or fix forward for a small, understood issue. The change request fixes the decision points in advance (go/no-go after install, migration failure, failed smoke tests) and a time box after which rollback starts without debate. Secrets are their own backup. A gitlab-backup without gitlab-secrets.json cannot decrypt CI variables, 2FA secrets or runner tokens. The runbook backs it up separately and expects the restore to be tested. Operator safety is a chapter, not a footnote. Bastion sessions time out. Every step runs inside tmux or screen with a script log, so a migration never dies with the operator's session. Docs are linted like code. CI runs markdownlint over the docs and ShellCheck over the script."},{"id":"projects/gitlab-omnibus-upgrade-playbook#results--evidence","title":"gitlab-omnibus-upgrade-playbook","url":"/projects/gitlab-omnibus-upgrade-playbook/#results--evidence","section":"Results & evidence","text":"- The case study spans 12.x to a supported 19.x target, planned as grouped hops, each with a VM snapshot and gitlab-backup taken first, and each gated on gitlab:check and background migrations reaching zero. - What actually took time is recorded honestly: migration waits at certain stops, the bundled PostgreSQL upgrades, and re-registering runners for the newer token workflow. - Six lessons learned are written up in the README, from pinning every package version to reindexing PostgreSQL when the OS or glibc version changes. - Copy-and-fill hop checklist and change-request templates make the process repeatable by someone other than me."},{"id":"projects/gitlab-omnibus-upgrade-playbook#limitations--next-steps","title":"gitlab-omnibus-upgrade-playbook","url":"/projects/gitlab-omnibus-upgrade-playbook/#limitations--next-steps","section":"Limitations & next steps","text":"- Guidance, not automation. It is a runbook with one evidence script. The hops themselves are run by an operator, deliberately, but that means the process is only as consistent as the person following it. - Scoped to single-node and small Omnibus installs. Multi-node and Helm-chart deployments have different upgrade mechanics. - Version specifics age. Required stops change with every GitLab release, so the official upgrade documentation stays the source of truth for any exact version. - Next: turn the gate into a script that blocks on the migration queue and diffs before and after evidence automatically."},{"id":"projects/stacks-ignite-fbe-lzvending-template-aks","title":"Landing-zone vending + AKS template","url":"/projects/stacks-ignite-fbe-lzvending-template-aks/","section":"Summary","text":"Landing-zone vending + AKS template: A sanitised copy of the source template a landing-zone vending workflow uses to scaffold AKS workload subscriptions: private AKS, spoke networking, optional data and edge services, and a two-region promotion pipeline. One template, scaffolded per application: vending creates the repo, the template creates the landing zone. Moves ingress from a Helm-managed NGINX release to the AKS App Routing add-on with a Terraform removed block, no manual state surgery. Front Door reaches a private cluster through an internal NGINX controller and an AKS-created Private Link Service. Two parallel region chains promote DEV to UAT to PRD after a shared build and cost-estimate stage. 6 environment × region workspaces; 3 ingress patterns behind feature flags; 24 Checkov suppressions, each justified; 2 regions promoted in parallel. Project: open-source platform, 2026, active. Stack: Terraform 1.13, azurerm ~> 4.62, azapi, Azure Verified Modules, Azure/aks/azurerm 11.3.0, AKS App Routing add-on, Azure Front Door + Private Link Service, GitHub Actions (reusable workflows), Infracost, Checkov, TFLint, taskctl. Code: https://github.com/rakshith-ponnappa/stacks-ignite-fbe-lzvending-template-aks"},{"id":"projects/stacks-ignite-fbe-lzvending-template-aks#the-problem","title":"Landing-zone vending + AKS template","url":"/projects/stacks-ignite-fbe-lzvending-template-aks/#the-problem","section":"The problem","text":"On a retail client's Azure platform, application teams needed AKS landing zones that were consistent, compliant and quick to stand up, across three environments and two regions. Hand-building each one produced drift. The answer was landing-zone vending: a provisioning workflow scaffolds a new application repository from a source template, and that repository's pipeline builds the landing zone. This is a public, sanitised copy of the AKS source template I worked on. Placeholder tokens such as APPLICATION_NAME are expected and must stay unresolved here, because the vending workflow fills them in when it scaffolds a new repository."},{"id":"projects/stacks-ignite-fbe-lzvending-template-aks#how-it-works","title":"Landing-zone vending + AKS template","url":"/projects/stacks-ignite-fbe-lzvending-template-aks/#how-it-works","section":"How it works","text":"The root module in deploy/core/terraform composes the landing-zone substrate: - Naming and tagging from versioned shared modules, and resource groups per component from the Azure Verified Module. - Spoke networking with VNet DNS servers taken from the identity remote state. Connectivity remote state supplies the virtual hub and private DNS zones; management remote state supplies the Azure Monitor Private Link Scope that the workload Log Analytics workspace joins. - A private AKS cluster with local accounts disabled, host encryption on both node pools, user-defined-routing egress, workload identity, an OIDC issuer, and a system pool tainted CriticalAddonsOnly so workloads run on the user pool. - Optional services behind flags: ACR, Front Door, PostgreSQL Flexible Server and Key Vault, mostly through Azure Verified Modules. - Three ingress patterns: an internal NGINX controller from the App Routing add-on fronted by a Private Link Service for Front Door; AGIC on a brown-field Application Gateway; and an Application Gateway network-isolation variant. Each repository has six workspace variable files (dev, uat and prd in East US 2 and Central US). The core pipeline runs a shared build and an Infracost estimate, then two parallel chains: DEV, UAT and PRD in East US 2, and the same in Central US, joining at a final tagging stage. Pull requests run the DEV East US 2 path only, and Central US is opt-in. Application-layer resources (namespaces, databases, Front Door endpoints, WAF policies, workload identity bindings) are deliberately left to a separate app-orchestration workflow."},{"id":"projects/stacks-ignite-fbe-lzvending-template-aks#engineering-decisions","title":"Landing-zone vending + AKS template","url":"/projects/stacks-ignite-fbe-lzvending-template-aks/#engineering-decisions","section":"Engineering decisions","text":"Retire the Helm ingress with a removed block. NGINX ingress on AKS was being retired in favour of the managed App Routing add-on. Rather than asking every derived repository to edit state by hand, the template declares removed { from = module.ingress } with destroy = true, so the next apply cleanly destroys the old Helm release without provider cycles. The default App Routing controller is disabled natively, and an internal NginxIngressController takes its place. kubectl_manifest over kubernetes_manifest. The App Routing CRD does not exist until the cluster does, and kubernetes_manifest needs the CRD schema at plan time, which fails on first apply. kubectl_manifest applies like kubectl and does not. Clean up what AKS creates behind your back. The Private Link Service is created by AKS as a side effect, not by Terraform, and it holds a reference to the internal load balancer that blocks destroy. A terraform_data destroy provisioner deletes it with the Azure CLI and waits for Azure to release the references. Explicit waits for eventual consistency. RBAC and network-isolation features in Azure are eventually consistent. The template uses named time_sleep resources (90 seconds for DNS-zone role propagation before cluster creation, 60 and 120 seconds after it, 120 for the PLS, 300 for Application Gateway isolation) rather than relying on retries. Suppressions are documented, not silent. All 24 Checkov suppressions are listed in the README with a reason, from module-source pinning conventions to WAF being enforced at Front Door rather than at the Application Gateway. Lock state down after apply. Every deploy job asks the shared template to lock down both regional state storage accounts after apply, and the backend uses Entra ID auth."},{"id":"projects/stacks-ignite-fbe-lzvending-template-aks#results--evidence","title":"Landing-zone vending + AKS template","url":"/projects/stacks-ignite-fbe-lzvending-template-aks/#results--evidence","section":"Results & evidence","text":"- The README was last validated against the code on 2026-03-30 and documents every root module, external module version, provider constraint, input, output, required variable and secret, and workflow permission. - Validation entry points cover pre-commit, terraform fmt and validate, TFLint, Checkov with the suppression file, and terraform-docs. - This template is the pattern behind the AKS ingress retirement I scoped as part of an Azure landing zone audit, written up in my work case studies."},{"id":"projects/stacks-ignite-fbe-lzvending-template-aks#limitations--next-steps","title":"Landing-zone vending + AKS template","url":"/projects/stacks-ignite-fbe-lzvending-template-aks/#limitations--next-steps","section":"Limitations & next steps","text":"- Not runnable on its own. It depends on private shared pipeline templates, naming and tagging modules, self-hosted regional runners and remote state from platform stacks that are not in this repository. - Service-principal secret authentication. The pipeline still expects ARM_CLIENT_SECRET; moving to OIDC federated credentials would remove a long-lived secret. - Cost estimates cover East US 2 only. Central US deployments are not estimated. - Fixed waits are a trade-off. Sleeps make applies slower and still assume propagation finishes in time. - Next: OIDC for the pipeline, cost estimates for both regions, and a pinned commit SHA for module sources in place of the tag convention Checkov currently has suppressed."},{"id":"projects/jenkins-k8s-pipeline-lab","title":"jenkins-k8s-pipeline-lab","url":"/projects/jenkins-k8s-pipeline-lab/","section":"Summary","text":"jenkins-k8s-pipeline-lab: My 2019 hands-on lab for running Jenkins agents as ephemeral Kubernetes pods, kept as an archive of an early Kubernetes CI lab, with a 2026 retrospective. Builds run in throwaway pod containers, never on the Jenkins controller. A Selenium hub and Chrome and Firefox nodes as sidecars in one pod, with Maven tests in parallel against both browsers. End-to-end Hugo CI/CD: build, link-check, image build and push, rolling update with kubectl. An honest 2026 retrospective on what I would replace today. 3 pipeline patterns; ~12 experiment repos merged into one; 5 containers in the Selenium pod; 2019 original build year. Project: open-source platform, 2019, archived. Stack: Jenkins, Jenkins Kubernetes plugin, Scripted Groovy pipelines, Kubernetes, Docker, Selenium Grid 3, Maven, Hugo, html-proofer, nginx. Code: https://github.com/rakshith-ponnappa/jenkins-k8s-pipeline-lab"},{"id":"projects/jenkins-k8s-pipeline-lab#the-problem","title":"jenkins-k8s-pipeline-lab","url":"/projects/jenkins-k8s-pipeline-lab/#the-problem","section":"The problem","text":"In 2019 the usual Jenkins setup was a long-lived controller with a few static build agents, each slowly accumulating toolchains, caches and state. Builds interfered with each other and agents were snowflakes. The Jenkins Kubernetes plugin offered a different model: ask the cluster for a pod made of purpose-built containers, run the stages inside them, and throw the pod away afterwards. I built this lab to learn that model properly. It is an archive. I merged about a dozen small experiment repositories into one, kept the pipelines as I wrote them, removed personal identifiers, and filled in one Hugo build step that had been left empty."},{"id":"projects/jenkins-k8s-pipeline-lab#how-it-works","title":"jenkins-k8s-pipeline-lab","url":"/projects/jenkins-k8s-pipeline-lab/#how-it-works","section":"How it works","text":"Three folders, each a step up in complexity. 01-golang-utility-pod is the minimal pattern: podTemplate declares a single golang container, node(label) schedules the pod, and container('golang') runs the step inside the toolchain container rather than on the controller. 02-selenium-parallel-browsers puts five containers in one pod: two Maven containers, a Selenium Grid hub, and Chrome and Firefox nodes as sidecars. Because containers in a pod share a network namespace, the browser nodes are pointed at localhost:4444 for the hub and moved to ports 5556 and 5557 to avoid clashing. A parallel block then runs the Maven test suite against Firefox and Chrome at the same time. It is based on the Kubernetes plugin's public Selenium example. 03-hugo-site-cicd is a full delivery pipeline in a four-container pod: 1. hugo builds the static site. 2. html-proofer validates links, failing on 4xx responses. 3. docker builds an nginx-based image and pushes it tagged with the build number and latest. 4. kubectl runs kubectl set image against the hugo-app Deployment for a rolling update. Kubeconfig and Docker registry credentials are mounted into the containers from Kubernetes secrets rather than stored in Jenkins."},{"id":"projects/jenkins-k8s-pipeline-lab#engineering-decisions","title":"jenkins-k8s-pipeline-lab","url":"/projects/jenkins-k8s-pipeline-lab/#engineering-decisions","section":"Engineering decisions","text":"One tool per container. Each stage runs in an image that does one thing. Toolchain upgrades become an image tag change, and nothing leaks between builds because the pod is discarded. Sidecars over a shared grid. Running the Selenium hub and browsers inside the build pod gave every build its own isolated grid. The trade-off is a heavier pod and port juggling on a shared localhost. Immutable build tags plus a moving tag. Deploying by build number made each rollout traceable to one Jenkins run, while latest was kept for convenience. Credentials from the cluster. Mounting secrets as volumes kept registry and cluster credentials out of the Jenkins credential store and out of the Jenkinsfile."},{"id":"projects/jenkins-k8s-pipeline-lab#results--evidence","title":"jenkins-k8s-pipeline-lab","url":"/projects/jenkins-k8s-pipeline-lab/#results--evidence","section":"Results & evidence","text":"- Three working pipeline patterns, from a single utility container to a full build, test and deploy loop on Kubernetes. - The Hugo pipeline's prerequisites are documented: two secrets, an existing Deployment and one job variable. - Third-party content keeps its own licence (the Hugo theme is MIT), and my pipeline code is MIT. There are no tests or metrics here; this is a learning lab, and I present it as one."},{"id":"projects/jenkins-k8s-pipeline-lab#limitations--next-steps","title":"jenkins-k8s-pipeline-lab","url":"/projects/jenkins-k8s-pipeline-lab/#limitations--next-steps","section":"Limitations & next steps","text":"This is a 2019 archive and I am not maintaining it. Looking back from 2026, I would change most of it: - Scripted podTemplate would become declarative pipelines with a kubernetes { yaml ... } agent. - Mounting the host Docker socket gives a build container root-equivalent access to the node. I would use rootless Kaniko or BuildKit builds instead. - kubectl set image from CI would become GitOps with Argo CD or Flux, so the cluster pulls desired state rather than CI pushing it. - Floating image tags (golang, docker, latest) would be pinned to versions and digests, with Trivy scanning and SBOMs added. - Deprecated syntax. The first pipeline uses the old stage 'name' form, and the Selenium images are from the 3.x era. It stays public because it is where my platform engineering started, and the gap between it and my current work is part of the story."},{"id":"projects/fde-coach","title":"fde-coach","url":"/projects/fde-coach/","section":"Summary","text":"fde-coach: A zero-dependency Python CLI that structures preparation for Forward Deployed Engineer and AI platform interviews: a 26-week curriculum, a daily coach with pacing and streaks, and a job finder over 87 companies' public job-board APIs. Standard library only: urllib, sqlite3, tomllib, argparse and concurrent.futures cover everything. Curriculum and job filters are TOML data, so the plan adapts without touching Python. Polls Greenhouse, Lever and Ashby boards concurrently over public APIs; no logins, no scraping. Visa-sponsorship hints judged sentence by sentence, so a 'yes' is not cancelled by a caveat elsewhere. 32 offline unittest tests; 87 company job boards polled; 26 weeks in the curriculum; 0 third-party dependencies. Project: open-source tools, 2026, active. Stack: Python 3.11+ (stdlib only), argparse, sqlite3, tomllib, urllib, concurrent.futures, unittest, GitHub Actions. Code: https://github.com/rakshith-ponnappa/fde-coach"},{"id":"projects/fde-coach#the-problem","title":"fde-coach","url":"/projects/fde-coach/#the-problem","section":"The problem","text":"Moving from cloud and platform engineering into Forward Deployed Engineer and applied-AI roles means running two projects at once: closing the skills gap and running a job search. Both usually live in a pile of spreadsheets, bookmarks and job-site tabs. The learning side needs a plan and honest pacing. The search side needs a steady feed of relevant roles without logging into a dozen sites or scraping anything. I built fde to hold both in one terminal command, for my own transition first, in a form anyone could fork."},{"id":"projects/fde-coach#how-it-works","title":"fde-coach","url":"/projects/fde-coach/#how-it-works","section":"How it works","text":"fde is an argparse CLI over three modules and a SQLite file at data/fde.db. learning.py reads curriculum.toml: a 16-week sprint from new-to-Python to job-ready, then a 10-week depth track. fde today works out the current week from the plan start date, reports whether I am ahead or behind, shows the streak and this week's logged hours, and prints a four-hour session template with a different shape for Sundays (finish the deliverable, review from memory, write the weekly report). fde log records hours, fde week done marks a week shipped with a note, and fde skills tracks 21 skills on a 0 to 5 scale against targets. jobs.py reads the company list from config.toml; the shipped example has 87 entries, each a name, an ATS (greenhouse, lever or ashby) and a board slug. fetch_all pulls the boards concurrently with a thread pool over urllib, and per-ATS parsers normalise postings. Each posting is then: - Tiered by title regex: A for FDE and deployment roles, B for applied AI and AI platform, C for platform, SRE and DevOps. Junior or irrelevant titles are excluded. - Region-tagged by configurable location regexes, with separate handling for remote roles. - Checked for sponsorship. sponsorship_of() splits the description into sentences and returns yes, no, relocation, or not stated. Jobs move through a pipeline (new, shortlisted, applied, interviewing, offer) with notes and follow-up reminders. fde jobs skills counts which skill keywords recent FDE-style ads mention, and fde jobs links builds LinkedIn searches to open by hand. report.py writes a dated Markdown progress report."},{"id":"projects/fde-coach#engineering-decisions","title":"fde-coach","url":"/projects/fde-coach/#engineering-decisions","section":"Engineering decisions","text":"Standard library only. A personal tool should install anywhere and never break on a dependency update. urllib, sqlite3, tomllib, argparse and concurrent.futures covered every need. A launcher script adds the repo to PYTHONPATH, so there is no install step at all. Plans and filters are data. The curriculum, tier regexes, region regexes and skill keywords are all TOML. Someone on a different path edits a file, not Python. A unit test checks that curriculum.toml stays internally consistent after edits. Sentence-level sponsorship parsing. Job ads hedge. \"We do sponsor visas! We can't sponsor every role.\" should read as yes, and \"we're unable to offer visa sponsorship\" as no. Matching per sentence and letting an explicit yes win is more accurate than a single regex over the whole text. US abbreviations are normalised first so \"U.S.\" does not end a sentence early. Respectful by default. Only public, unauthenticated job-board APIs are used: no logins, no scraping and no browser automation. Each board is fetched at most once a day from fde today, or on an explicit fde jobs fetch. Sites without an API get a link, not a crawler. SQLite for state. One portable file, with real queries behind the pipeline counts, follow-ups and reports."},{"id":"projects/fde-coach#results--evidence","title":"fde-coach","url":"/projects/fde-coach/#results--evidence","section":"Results & evidence","text":"- 32 unittest tests, all offline, with HTTP mocked and temporary directories. They cover the three ATS parsers, tiering, region filters, sponsorship detection, pacing and streak maths, the CLI, and curriculum consistency. - CI runs the suite on GitHub Actions. - About 1,200 lines of Python across six modules, with a fully commented working config.example.toml that is used until a personal config.toml exists."},{"id":"projects/fde-coach#limitations--next-steps","title":"fde-coach","url":"/projects/fde-coach/#limitations--next-steps","section":"Limitations & next steps","text":"- Three ATS providers. Companies on Workable, SmartRecruiters or in-house careers sites are not covered; those are next on the roadmap. - Tiering is regex on titles. It is fast and explainable, but misses roles with unusual titles and does not read the description for fit. - The sponsorship hint is a hint. It reflects the ad's wording, not a company's actual policy. - The curriculum is opinionated. Its baselines assume an experienced cloud engineer who is new to Python and AI. - Next: more ATS providers, CSV or calendar export of the pipeline, and an optional LLM summary that matches job descriptions against my skill ratings."},{"id":"projects/bhagamandala-house-3d","title":"bhagamandala-house-3d","url":"/projects/bhagamandala-house-3d/","section":"Summary","text":"bhagamandala-house-3d: An interactive Three.js walkthrough of a G+1 house inspired by Kodagu's Ainmane heritage, with a Python pipeline that regenerates plan images and multilingual PDFs and a GitHub Pages deployment. A single-file WebGL viewer with no build step: orbit, fly-to rooms, X-ray walls, exploded view and day/night. Procedural canvas textures for laterite, wood, Kota stone and roof tiles instead of downloaded image assets. One Python pipeline regenerates six plan images and the PDF set, then checks the 3D model is in sync. Plans documented in English, Kannada and Malayalam for everyone involved in the build. 18 rooms modelled across two floors; ~2,909 sq ft built-up area, G+1; 3 documentation languages; 6 generated plan and elevation images. Project: open-source tools, 2026, active. Stack: Three.js r0.164.1, WebGL, Vanilla HTML/CSS/JS, Python, Pillow, matplotlib, fpdf2, GitHub Actions, GitHub Pages. Code: https://github.com/rakshith-ponnappa/bhagamandala-house-3d"},{"id":"projects/bhagamandala-house-3d#the-problem","title":"bhagamandala-house-3d","url":"/projects/bhagamandala-house-3d/#the-problem","section":"The problem","text":"Designing a family house means explaining one design to very different people: family members who read plans differently, a builder who works from dimensions, and relatives more comfortable in Kannada or Malayalam than in English. Flat drawings did not survive that. People kept asking what a room would actually feel like, which walls are exposed laterite, and what the veranda looks like from the road. So I treated the design like software. The house is a G+1 residence on a 60 × 50 ft east-facing plot, drawing on the Kodagu Gowda Ainmane tradition: exposed laterite (jambitt kallu) bedroom walls sealed with linseed oil, a 42 × 8 ft jagali veranda on five teak pillars, and a hip-and-gable Mangalore tile roof. I wanted one source of truth that produces a walkable 3D model, printable plans and translated documents. Live viewer: rakshith-ponnappa.github.io/bhagamandala-house-3d"},{"id":"projects/bhagamandala-house-3d#how-it-works","title":"bhagamandala-house-3d","url":"/projects/bhagamandala-house-3d/#how-it-works","section":"How it works","text":"The 3D viewer is a single HTML file of about 925 lines that loads Three.js r0.164.1 and OrbitControls from a CDN. It models 18 rooms (11 on the ground floor, 7 on the first) from a room definition table holding each room's dimensions, wall finish, flooring and orientation. Materials are MeshStandardMaterial with procedurally drawn CanvasTextures, so laterite, tile and stone surfaces need no image downloads. The interface adds: - floor filters (ground, first, site or all) and camera presets (bird's eye, front, inside the ground floor, sitout); - a room panel listing all 18 rooms, where a click flies the camera to the room and opens a detail card with finishes and features; - keyboard toggles for reset (R), exploded view (E), X-ray walls (X) and night mode (N); - a heritage badge on rooms with exposed laterite. The pipeline, pipeline.py --all, runs four steps and reports how many succeeded: 1. generate_plans_v4.py draws six images (ground and first-floor plans, front and back elevations, roof and site layout) with Pillow and matplotlib. 2. generate_pdfs.py builds the PDF set with fpdf2, including the English, Kannada and Malayalam plan documents. 3. A sync check counts the room entries in the viewer, compares them against the generator, and warns if the viewer is stale. 4. The project context document gets a \"last pipeline run\" timestamp. build_website.py assembles a landing page and copies plan images into docs/. A GitHub Actions workflow deploys the viewer to GitHub Pages on every push to main."},{"id":"projects/bhagamandala-house-3d#engineering-decisions","title":"bhagamandala-house-3d","url":"/projects/bhagamandala-house-3d/#engineering-decisions","section":"Engineering decisions","text":"No build tooling for the viewer. A single static file opens from any HTTP server and deploys to Pages with no bundler, which suits a project people visit more than they develop. Procedural textures. Drawing textures on a canvas keeps the repository small and lets me tune colour and pattern in code next to the material that uses them. Data-driven rooms. Every room lives in one table in the viewer, so the room panel, detail cards, fly-to targets and heritage badges all derive from the same data instead of being hand-placed. Translations as first-class artefacts. The Kannada and Malayalam documents are generated outputs, not afterthoughts, because the people who build and live in the house need them. Generated outputs are reproducible. Images and PDFs are regenerated from scripts, so a design change propagates to every artefact in one command."},{"id":"projects/bhagamandala-house-3d#results--evidence","title":"bhagamandala-house-3d","url":"/projects/bhagamandala-house-3d/#results--evidence","section":"Results & evidence","text":"- 18 rooms across two floors, about 2,909 sq ft built up on a 42 × 38 ft footprint including the veranda. - Six plan and elevation images and a PDF set in three languages, all regenerated by one command. - A deployed, browser-based walkthrough that anyone with the link can explore without installing anything."},{"id":"projects/bhagamandala-house-3d#limitations--next-steps","title":"bhagamandala-house-3d","url":"/projects/bhagamandala-house-3d/#limitations--next-steps","section":"Limitations & next steps","text":"- Licence. The design, plans, renders, documents and code are licensed CC BY-NC-ND 4.0. You may view and share them with credit, but not use them commercially or create derivative designs. It is source-available for viewing, not open source in the usual sense. - Room data is duplicated. The viewer and the plan generator each hold their own room definitions, and the \"sync\" step only counts entries and checks timestamps. A single shared JSON source would make drift impossible rather than merely visible. - No automated tests, and the pipeline's dependencies are installed by hand rather than pinned. - Older versions sit alongside current ones (index_v1.html in both 3d-viewer/ and docs/). - Next: extract room data into one JSON file consumed by both the viewer and the generators, and add a CI check that the generated artefacts are current."}]}