Justin Johnson

Takes a Java Spring Boot service the whole way to production: a Maven build, a small container image, a Helm chart on Kubernetes that rolls out new versions with no failed requests, a pipeline that publishes every tested commit, and a Kafka lab for event streaming. Each stage was tested on purpose, including breaking things to measure what goes wrong.

• Multi-stage Dockerfile: Maven and the JDK build the app, only the JRE and JAR ship, running as a non-root user
• Reproduced an OOMKill (exit code 137) in a 256 MB container, then fixed it with container-aware heap sizing
• Helm chart with startup, readiness and liveness probes, graceful shutdown and atomic rollback
• GitHub Actions builds, tests and checks the chart, then publishes images tagged by commit
• Kafka lab on consumer groups and lag, including a hot partition caused by key skew
• Every result is written up in the repository, with commands to reproduce it

Reads a support ticket export and answers three questions: what customers contact you about, which of those contacts can be handled without a person, and what the difference is worth per month. The output is one shareable report with every input and its source printed on the page. Sample run on a public dataset of 26,872 support messages.

• 27 raw intents grouped into 16 contact reasons, each tagged by how it should be resolved
• Readable rules classify 88.1% correctly on held-out tickets, four passes to get there
• A local model handles only what the rules cannot match, taking the total to 95.8%
• Weak matches are held for a person rather than guessed, so confident misrouting stays rare
• Containment targets are cut by measured accuracy, so the business case never assumes perfect routing
• Every assumption, limitation and reversed decision is recorded in the repository

Four AWS builds, each documented the way a team would hand it over: architecture, security, operations and teardown notes, with decision records for the key trade-offs. Built and tested in a live AWS account, and the static site deploys through GitHub Actions with OIDC, so no AWS keys are stored.

• Serverless REST API on API Gateway, Lambda and DynamoDB, with decision records on Lambda vs EC2 and DynamoDB vs RDS
• Event-driven system with SNS, SQS and dead-letter queues, with failure handling documented
• Secure static delivery with S3 and CloudFront, using a private origin
• GitHub Actions deploys through OIDC, with zero long-lived AWS credentials
• Security, operations and teardown notes for every build
• Built and tested in a live AWS account, with screenshots as evidence

A GitHub Actions pipeline that builds Azure infrastructure with Terraform without storing a single password. Every pull request gets a security scan and a Terraform plan posted for review, and production changes wait for a person to approve them.

• Workload identity federation, no secrets in GitHub
• Least-privilege identity scoped to one resource group
• Format check, Checkov scan and plan on every PR
• Protected prod environment with a required approver
• State in Azure Storage: keyless, versioned, locked
• Drift caught by plan and traced in the Activity Log

End-to-end LLMOps platform built to production deployment standards: model serving, RAG pipelines with vector search, CI/CD-gated evaluation, Prometheus observability, and multi-agent orchestration — deployed on containerized infrastructure reflecting enterprise AI patterns.

• Full LLMOps lifecycle: model serving, RAG, CI/CD evaluation, and observability
• Local-first inference via Ollama, with optional fallback to Amazon Bedrock; MLflow experiment tracking
• DevOps AI agent with Docker socket access for container orchestration via natural language
• CI/CD evaluation gate: automated pytest eval suite runs on every model or prompt change
• Production observability: Prometheus, Grafana, and Evidently AI for model drift monitoring
• Multi-agent orchestration with streaming React/WebSocket UI