DevOps practice through my own build and deploy workflows
I have not held a DevOps Engineer title yet. What I do have are repeated reps with GitHub Actions, Docker Compose, build validation, and deployment notes across my own projects.- GitHub Actions: linting, type-checking, and build validation before deploys.
- Docker Compose: repeatable local environments for Node, Python, and Zig experiments.
- Deployment checks: personal workflows that stop deploys when builds fail.
- Documentation: READMEs that spell out missing health checks, rollback gaps, and manual steps.
Clear scope, upfront
What I have
- Personal CI scripts and deployment checklists for personal projects.
- Local Docker Compose labs to practice repeatable environments.
- Documentation practices that record failures and remediation steps.
What I am still working toward
- Ownership of production CI/CD workflows or multi-team delivery pipelines.
- Rollback drills and approvals in a real shared delivery environment.
- Deeper observability stacks beyond basic logs and alerts.
What I’m doing next
- Required checks and manual approvals before deploy steps in sandbox workflows.
- Monitoring practice beyond Lighthouse and console logs.
- Policy-as-code exercises for secrets and access control.
What 'DevOps' means in my world today
Personal automation (public)
Most of my DevOps practice comes from automating my own releases and making small projects harder to break.
- GitHub Actions pipelines run linting, type-checking, and build validation before publishing to Netlify or GitHub Pages.
- Docker Compose labs to standardize Node, Python, and Zig tooling in local development environments.
- Scripts and deployment notes documented in repository READMEs.
Guided exposure (lab-style)
The AWS internship added some operational context, but it was still guided exposure rather than owning shared pipelines for a team.
- AWS internship exposure to ticket triage and CloudWatch dashboards in lab-style environments.
- Guided rotations only; no ownership of production changes or independent resolution of live customer tickets.
Evidence (student/volunteer level)
Docker Multilang
This project is less about shipping an app and more about standardizing local environments so onboarding and repeatability are easier.
- Compose file standardizes Node, Python, and Zig tooling for onboarding.
- Manual smoke tests are used in place of automated test suites; README documentation lists missing health checks.
- GitHub Actions builds images and runs linting before merge or deploy steps.
Portfolio deploys
This is where most of my practical CI/CD work shows up today: personal sites, demos, and deploy checks that block obvious mistakes.
- Netlify and GitHub Pages workflows validate builds before publishing personal sites and templates.
- Accessibility and Lighthouse checks run via CLI scripts.
- Build failures block deployments until issues are resolved.
What I'm practicing (always with AI pair-programming)
Each repository documents which tools are operational, experimental, or planned to indicate maturity and reliability.
Where I still need guidance
- Designing CI/CD for teams bigger than me, including approvals and rollback plans.
- Monitoring stacks beyond Lighthouse + console logs (e.g., Prometheus, Grafana).
- Hardening secrets management and policy-as-code beyond
.envfiles. - Incident response drills inside real production environments.
If you are hiring for junior DevOps or platform roles and provide coaching in these areas, I am open to discussing opportunities.
Core Responsibilities
A DevOps Engineer is responsible for automating build, test, and deployment workflows, and bridging the gap between development and operations. Key responsibilities include:
- CI/CD pipeline design: Building automated pipelines with GitHub Actions that run linting, type-checking, testing, and build validation before deploys (Source).
- Containerization: Creating repeatable local development environments with Docker and Docker Compose so onboarding and environment parity are easier (Source).
- Deployment automation: Configuring automated deploys to Netlify, GitHub Pages, or Render with build-failure gates that block broken releases.
- Infrastructure as Code (IaC): Provisioning cloud resources with Terraform instead of manual console changes (Source).
- Monitoring and observability: Setting up logging, alerting, and dashboards to detect issues before users report them. Tools like Prometheus and Grafana are industry standards.
- Secrets management: Storing API keys and credentials securely using environment variables, GitHub Secrets, or vault tools — not hardcoded in source.
- Rollback and recovery: Designing deployment strategies that support rollback when a release introduces regressions.
Key Skills
- CI/CD: GitHub Actions (Source), Netlify CLI (Source)
- Containers: Docker (Source), Docker Compose (Source)
- Infrastructure as Code: Terraform (Source)
- Scripting: Bash (Source), Python (Source)
- Cloud CLI: AWS CLI (Source)
- Monitoring: Prometheus (Source), Grafana (Source), Lighthouse CLI (Source)
- Load testing: k6 (Source)
- Deployment platforms: Netlify (Source), GitHub Pages (Source), Render (Source)
Tools and Technologies
| Tool | Category | My Maturity Level | Official Docs |
|---|---|---|---|
| GitHub Actions | CI/CD | Personal CI basics | GitHub Actions |
| Netlify CLI | Deployment | Personal deploys | Netlify CLI |
| Docker / Docker Compose | Containerization | Local dev labs | Docker |
| AWS CLI | Cloud CLI | Lab only | AWS CLI |
| Bash | Scripting | Local automation | Bash Manual |
| Terraform | Infrastructure as Code | Tutorial stage | Terraform |
| k6 | Load testing | Local only | k6 |
| Lighthouse CLI | Performance auditing | Personal projects | Lighthouse |
Role Comparison: DevOps Engineer vs. Adjacent Roles
| Dimension | DevOps Engineer | Cloud Engineer | Backend Engineer | Platform Engineer |
|---|---|---|---|---|
| Primary focus | CI/CD, deployments, automation | Cloud infra design, IaC, cost | Server logic, APIs, databases | Internal developer platforms |
| Core tools | GitHub Actions, Docker, Bash | Terraform, AWS CLI, IAM | Express, FastAPI, MongoDB | Kubernetes, Backstage, Crossplane |
| Pipeline work | High — core responsibility | Medium — uses pipelines | Low — consumes pipelines | High — builds platform pipelines |
| Container expertise | High — builds images and compose | Medium — uses containers | Low | High — manages K8s clusters |
| Cloud provisioning | Medium — deploys to cloud | High — core responsibility | Low | High — provisions platform infra |
| On-call | Sometimes | Sometimes | Rarely | Sometimes |
| Typical deliverable | Working CI/CD pipeline | Provisioned cloud resources | Deployed API service | Self-service developer platform |
| My current level | Personal CI scripts | AWS internship | Small deployed APIs | Not pursuing |
Expanded Process Notes
How I approach setting up a CI/CD pipeline
- Define the build stages — Identify what needs to pass before a deploy: linting, type-checking, unit tests, and build validation. GitHub Actions uses YAML workflow files to define these stages (Source).
- Add build-failure gates — The pipeline should block deploys when any check fails. This prevents broken code from reaching production.
- Containerize the environment — Use Docker Compose to define a repeatable environment with consistent Node, Python, or other runtime versions. This eliminates "works on my machine" issues (Source).
- Store secrets securely — API keys and tokens are stored in GitHub Encrypted Secrets, never committed to the repository.
- Add smoke tests — After deploy, run basic checks (e.g., k6 load tests or Lighthouse audits) to verify the deployment is healthy.
- Document gaps — README documentation lists missing health checks, rollback procedures, and manual steps so the limitations are transparent.
Common pitfalls I have encountered
- No rollback plan: Without a rollback strategy, a bad deploy can take a site offline. Documenting a manual rollback process is a minimum first step.
- Hardcoded secrets: Storing API keys in
.envfiles that get committed is a common mistake. Using GitHub Secrets for CI pipelines is the safe approach. - Missing health checks: Without health check endpoints, deployment platforms cannot detect if a service is actually running. Adding a
/healthendpoint is a simple best practice (Source).
References
- GitHub Actions Documentation
- Docker Documentation
- Docker Compose Documentation
- Terraform Documentation
- Netlify Documentation
- Netlify CLI
- GitHub Pages Documentation
- Render Documentation
- AWS CLI User Guide
- Prometheus Documentation
- Grafana Documentation
- k6 Documentation
- Lighthouse CLI
- GitHub Encrypted Secrets
- Bash Manual
- Python.org
