Skip to content

DevOps Engineer

DevOps Engineer

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.
Honesty upgrade

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.
Reality snapshot

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.
Work samples

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.

Proof links: Containerization notes

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.

Proof links: CI/CD workflow notes

Tools in rotation

What I'm practicing (always with AI pair-programming)

GitHub Actions — personal CI basicsNetlify CLI — personal deploysDocker / Docker Compose — local dev labsAWS CLI labs — lab onlyBash scripting — local automationTerraform — tutorial stagek6 smoke tests — local only

Each repository documents which tools are operational, experimental, or planned to indicate maturity and reliability.

Help wanted

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 .env files.
  • 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

Tools and Technologies

ToolCategoryMy Maturity LevelOfficial Docs
GitHub ActionsCI/CDPersonal CI basicsGitHub Actions
Netlify CLIDeploymentPersonal deploysNetlify CLI
Docker / Docker ComposeContainerizationLocal dev labsDocker
AWS CLICloud CLILab onlyAWS CLI
BashScriptingLocal automationBash Manual
TerraformInfrastructure as CodeTutorial stageTerraform
k6Load testingLocal onlyk6
Lighthouse CLIPerformance auditingPersonal projectsLighthouse

Role Comparison: DevOps Engineer vs. Adjacent Roles

DimensionDevOps EngineerCloud EngineerBackend EngineerPlatform Engineer
Primary focusCI/CD, deployments, automationCloud infra design, IaC, costServer logic, APIs, databasesInternal developer platforms
Core toolsGitHub Actions, Docker, BashTerraform, AWS CLI, IAMExpress, FastAPI, MongoDBKubernetes, Backstage, Crossplane
Pipeline workHigh — core responsibilityMedium — uses pipelinesLow — consumes pipelinesHigh — builds platform pipelines
Container expertiseHigh — builds images and composeMedium — uses containersLowHigh — manages K8s clusters
Cloud provisioningMedium — deploys to cloudHigh — core responsibilityLowHigh — provisions platform infra
On-callSometimesSometimesRarelySometimes
Typical deliverableWorking CI/CD pipelineProvisioned cloud resourcesDeployed API serviceSelf-service developer platform
My current levelPersonal CI scriptsAWS internshipSmall deployed APIsNot pursuing

Expanded Process Notes

How I approach setting up a CI/CD pipeline

  1. 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).
  2. Add build-failure gates — The pipeline should block deploys when any check fails. This prevents broken code from reaching production.
  3. 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).
  4. Store secrets securely — API keys and tokens are stored in GitHub Encrypted Secrets, never committed to the repository.
  5. Add smoke tests — After deploy, run basic checks (e.g., k6 load tests or Lighthouse audits) to verify the deployment is healthy.
  6. 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 .env files 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 /health endpoint is a simple best practice (Source).

References