Resume

Work across Cloud Infrastructure, SRE, Developer Platform, Data Engineering, and Product Platform to align technical direction and build solutions that improve reliability, scalability, and cohesion across systems.

• Led company-wide dependency modernization, including the migration from custom Python tooling to uv, improving builds and CI workflows while reducing Python and Go vulnerabilities by 80% across more than 100 services and addressing approximately 7,500 reported vulnerabilities.
• Built and demonstrated an AI-assisted software delivery platform to automate the end-to-end product lifecycle, integrating signals from Aikido, GitHub, and Jira.
  • Developed planning and implementation agents, durable task APIs, lifecycle tracking, and isolated Kubernetes preview environments.
  • Architected distributed components for ideation, planning, implementation, releasing, and monitoring, with each stage handled independently.
• Unified local development, system testing, and application-schema tooling behind a single developer CLI integrating Tilt, Kubernetes, and Testkube for service startup, debugging, ephemeral environments, logs, artifact collection, service discovery, and configuration management.

Led infrastructure development across Kubernetes, Terraform, and Go, delivering internal tooling and deployment automation that enabled platform self-service and modernized legacy processes.

• Built an internal service catalog and developer portal using Go, React, and Redis, centralizing visibility into applications, repositories, dependencies, teams, and access roles. Exposed a web API and surfaced operational metrics, service status, errors, and vulnerabilities alongside service resources.
• Architected and implemented a Kubernetes operator with Kubebuilder (Go), enabling self-service deployment for 15 teams managing 300+ repositories and 120+ microservices.
  • Defined internal applications, environments, teams, and roles as Kubernetes custom resource definitions (CRDs), exposing resource operations through a Go API.
• Rebuilt the deployment CLI in Go using internal CRD interfaces and Helm, replacing brittle Bash scripts with catalog-driven service discovery, environment and cluster targeting, and dependency-aware deployments. Cut deployment time from 45 to 6 minutes and enabled parallel rollouts across more than 100 microservices.
• Built a custom Terraform provider in Go to automate resource discovery across more than 1,000 AWS and GCP assets, reducing code duplication by 70% and cutting workspace setup time from days to hours. Replaced brittle generated infrastructure configuration with provider data sources and added automated tests across all data sources.
• Developed declarative access management with Terraform, Okta, and application metadata, automating organizational groups, membership rules, and role assignments. Implemented Privileged Access Management through Kubernetes custom resources, connecting ADP-sourced identities with organizational mappings for dynamic, auditable access control.
• Created reusable GCP provisioning workflows for projects, networking, APIs, Terraform runners, and IAM; migrated development, staging, and production infrastructure with policies protecting against accidental deletion.
• Migrated DNS, CDNs, and storage buckets from AWS to GCP, including Route 53 to Cloud DNS, and standardized their management in an isolated Terraform workspace.
• Implemented connectivity across application clusters within a single region using an Istio service mesh. Improved multi-cluster operational readiness through deployment manifests, secondary-cluster workload scaling, and standardized cluster switchover procedures.
• Standardized Kubernetes health checks across Go services, separating liveness from dependency readiness and adding cached checks, bounded retries, and exponential backoff.
• Built Kubernetes controllers to retire inactive development namespaces and clean up associated Pub/Sub, FHIR, and Cloud Tasks resources.
• Standardized Go command-line tooling and mentored junior and mid-level engineers in Go, Kubernetes, and networking, increasing team velocity by 40% through shared engineering and operational practices.

Co-founded Virta’s initial SRE team, establishing incident response and observability practices while operating Kubernetes workloads, networking, and infrastructure as code.

• Defined company-wide incident response processes and on-call policy, establishing shared expectations for incident coordination and operational ownership.
• Developed an event-driven Slackbot integrating the PagerDuty API, reducing mean time to acknowledge by 65% and automating coordination across more than 200 incidents.
• Developed standardized metrics packages for Go and Python services, implemented consistent Prometheus metrics collection, and standardized Honeycomb usage across the company.
• Expanded distributed tracing and production monitoring through shared Python instrumentation, asynchronous HTTP/gRPC support, service alerts, and deployment markers.
• Established LLM observability with Arize Phoenix and OpenTelemetry, routing model traces separately from general application telemetry.
• Managed and maintained Kubernetes clusters and service networking with Istio and Anthos Service Mesh (ASM).
• Developed Kubernetes operators to automate GCP Secret Manager integration, workload secret delivery, and Kubernetes-to-GCP service account bindings.
• Decomposed a Terraform monolith managing tens of thousands of infrastructure resources into domain-bound workspaces with explicit dependencies, migrating state from Google Cloud Storage to Terraform Cloud.
  • Defined domain workspaces in YAML, reducing P1 incidents by 60% and cutting mean time to recovery from 4 hours to approximately 45 minutes.
  • Upgraded the Terraform codebase from 0.12 to 1.0 and later versions, reducing average release time by 45%.
• Strengthened CI/CD authentication with repository-scoped Google Workload Identity Federation, enforcing identity constraints and separating authentication configuration from monolithic infrastructure state. Automated credential rotation and eliminated manual key management for more than 100 service accounts.
• Established infrastructure as code for dedicated machine-learning environments, enabling Kubernetes provisioning and access to Cloud SQL, BigQuery, Artifact Registry, and Cloud Storage.
• Consolidated production and staging DNS in Google Cloud DNS through a dedicated Terraform workspace managing 25 domains and more than 800 records, migrating from Route 53 without downtime. Coordinated zone delegation and certificate issuer changes across application clusters.

Worked as a full-stack and backend engineer and DevOps consultant for mission-driven partners, primarily building Ruby on Rails and Python applications in healthcare, alongside projects in donations, email security, and journalism.

• Developed and maintained monolithic applications and backend APIs, translating complex domain requirements into data models, application logic, and user-facing workflows.
• Architected and implemented a donations platform across frontend, backend, and production infrastructure.
  • Built the React frontend and Ruby on Rails backend for physical goods donation logistics, including the supporting data models and APIs.
  • Handled system administration and containerized deployment on Azure with Docker Swarm, connecting application development with ongoing production operations.
• Introduced DevOps practices for partner teams using Terraform, GCP, Go, and Python to automate infrastructure and operational workflows.
• Worked with an email security company on efficient, secure database interactions for its email security platform, optimizing queries and API endpoints against a sharded table exceeding six billion rows, including partitioning for daily digest workflows.
• Refactored and extended healthcare applications and Ruby microservices, evolving data models and backend functionality to improve maintainability and reduce operational complexity.
• Integrated and refactored SAML-based single sign-on for the Minneapolis Star Tribune.

Worked primarily on backend engineering with Ruby on Rails, alongside frontend improvements to make application designs more consistent.

• Developed and maintained Rails backend features and integrations between application subsystems and the core content management platform.
• Created a style guide and standardized shared interface designs to support consistent implementation across the application.
• Built a Node.js application to analyze user cohorts, purchase behavior, and engagement metrics.

Worked as a frontend and backend generalist, building custom content management systems and web experiences for client projects.

• Developed custom CMS features and content models to support product marketing sites, blogs, and customer management applications.
• Implemented frontend interfaces and the backend functionality that powered content publishing and site administration.

• Improved CMS tools to let clients manage marketing campaigns and advertisements.

• Built and maintained web applications using PHP, Ruby on Rails, Django, JavaScript, HTML, and CSS.

Built a photography platform with Next.js, Go, Supabase, Google Cloud Storage, and Cloudflare R2, with asynchronous image processing and optional AI tagging and descriptions.

Built an AI fitness companion with buddy personas, conversational activity and goal management, Strava integration, and image analysis using Next.js, Supabase, and S3. The project is no longer running.

Contributed to Langchaingo, a Go library for building applications with language models.