US federal government agency

the US federal government agency needed to modernize a set of legacy on-premises IDP ("Dissemination Platform" — the expansion of the leading "I" is unconfirmed) applications to AWS. The legacy applications are 20+ years old and were poorly documented; the majority are written in Python, with some in Java/C++. The first phase was an architecture assessment of exactly 10 in-scope legacy applications, required within a compressed 3-month timeframe.

- Brought in as Application Architect to modernize the US federal government agency IDP legacy on-prem applications to AWS - Led Phase 1: architecture assessment of 10 in-scope legacy applications within a 3-month window - To accelerate delivery, focused on leveraging Claude Code with detailed prompts to analyze legacy code and documentation - Applied hands-on Python expertise (the majority of the legacy applications are Python) plus Claude Code to reverse-engineer poorly-documented, 20+-year-old legacy code and determine what each application actually did, in order to define the correct modernization approach - Established a reusable analysis framework (for using Claude Code to assess legacy systems) that was adopted by a 3-4 person team during Phase 1 - Delivered the Phase 1 architecture assessment on time, roughly 50% faster than a typical/expected manual assessment timeline for comparable legacy scope - Defined the future-state architecture and technology stack for the AWS migration, covering all 10 assessed applications - Partnered directly with the US federal government agency product owners and architects (client-side; exact titles not on record) to define the modernization approach and sequencing - Leads a 4-5 person team (Phase 2, implementation) leveraging Claude Code to modernize the assessed applications; of the 10, 2 legacy Java/C++ applications entered implementation — one is under active, ongoing implementation with Claude Code's assistance, the other reached a development AWS environment before the client redirected the team's focus to the other pilot after roughly two weeks of implementation work; the remaining 8 applications have been assessed and architected but have not yet entered implementation - Working through GitLab CI/CD pipelines and Terraform infrastructure-as-code scripts for the applications in implementation - Presents weekly demos to executive stakeholders on the client side - Scope evolved continuously as the team discovered integration requirements with external systems, requiring ongoing re-architecture rather than a fixed, one-time design — including the client's decision to redirect implementation focus between the two pilot applications - Engagement is ongoing — Phase 1 (assessment/architecture) is complete for all 10 applications; Phase 2 (implementation) is in progress on 2 of the 10, with the remaining 8 assessed and architected but awaiting implementation as of this writing

- Legacy state: on-premises backend data processing systems, 20+ years old, poorly documented, majority written in Python (some Java/C++), that integrate with Unidata LDM (Local Data Manager), processing incoming weather/sensor data and delivering it to downstream systems. Named legacy systems in scope include MRMS (Multi-Radar Multi-Sensor) and NGITWS (Next Gen IT Web Services). - Target/future state: AWS-based architecture using SNS (event/message notification), S3 (storage), EventBridge (event routing), EC2, and Kubernetes (container orchestration) — an event-driven, message-based architecture replacing the legacy on-prem data processing/dissemination model. Scope evolved continuously as external-system integration requirements were discovered, rather than being fixed upfront. - Delivery tooling: GitLab CI/CD and Terraform for infrastructure as code - AI-assisted delivery framework: Claude Code used in two distinct modes — 1. **Analysis mode** (Phase 1, complete for all 10 apps): detailed prompting, combined with Russell's own Python expertise, to reverse-engineer poorly-documented legacy code (mostly Python) and determine what each application did, accelerating the 10-app architecture assessment within the 3-month window to roughly 50% faster than a typical manual assessment 2. **Implementation mode** (Phase 2, in progress on 2 of 10): Claude Code used by a 4-5 person team to implement the modernization of 2 legacy Java/C++ applications so far — 1 actively ongoing, 1 paused after ~2 weeks when the client redirected focus to the other pilot; the remaining 8 assessed applications are architected but not yet in implementation

Assessing 10 legacy backend data-processing applications — 20+ years old, poorly documented, integrated with an external system (Unidata LDM) and each other via downstream data delivery — within a compressed 3-month timeframe; reverse-engineering undocumented legacy code (mostly Python) using Claude Code to determine actual application behavior before a modernization approach could even be defined; establishing and rolling out a new AI-assisted analysis/build framework across a team rather than relying on it individually; scope continuously evolving as external-system integration requirements were discovered rather than being fixed at the outset, including a client-driven pivot in which implementation pilot to prioritize

Delivered the Phase 1 architecture assessment (10 legacy applications) on time, roughly 50% faster than a typical/expected manual assessment timeline for comparable scope, using a Claude-Code-based analysis framework combined with hands-on Python code review. Defined the future-state AWS architecture and technology stack for all 10 applications. In Phase 2, 2 of the 10 legacy Java/C++ applications have entered implementation with Claude Code's help — 1 is actively ongoing, 1 reached a development AWS environment before the client redirected focus to the other pilot after roughly two weeks of implementation work. The remaining 8 applications have been assessed and architected but have not yet entered implementation. Engagement continues (end date "Present"); revisit as Phase 2 implementation progresses.

Two distinct team-leadership motions within one engagement: established and led a 3-4 person team through a Claude-Code-assisted architecture assessment framework (Phase 1, complete for all 10 applications); currently leads a 4-5 person team (Phase 2) implementing the modernization of 2 of those 10 applications with Claude Code — 1 actively ongoing, 1 paused after ~2 weeks of implementation when the client redirected focus to the other pilot. The remaining 8 assessed applications are architected but not yet in implementation. Partnered directly with the US federal government agency product owners and architects on the client side to define the modernization approach and sequencing, including the client's decision to redirect implementation priority between the two pilots. Presents weekly demos directly to executive stakeholders on the client side.