Engineering Practice
Engineering Learning Lab
A practical roadmap through Linux, containers, CI/CD, and backend-oriented infrastructure work.
This page documents what I am practicing, what I am refining, and what I plan to study next. The structure separates completed work, current experiments, and planned learning so the evidence stays clear.
Completed
Current
Planned
Featured Checkpoints
Highlights from completed work and active practice, written as engineering notes rather than polished claims.
VCS
Git Fundamentals
Get comfortable reading commit history and using branches without breaking shared work.
Objective
Get comfortable reading commit history and using branches without breaking shared work.
What I practiced
- Reading commit graphs with log --graph
- Interactive rebase to squash and reorder commits
- Resolving merge conflicts on feature branches
OS
Linux Fundamentals
Build day-to-day fluency with Linux commands for server debugging and automation prep.
Objective
Build day-to-day fluency with Linux commands for server debugging and automation prep.
What I practiced
- Navigating and editing files from the shell
- Checking process status and system load
- Fixing permission issues with chmod and chown
Automation
Bash Scripting
Write shell scripts that automate setup checks and deployment prep with basic error handling.
Current experiments
- Refining small scripts for local environment checks
- Testing safe failure handling in shell workflows
- Documenting how I structure scripts for readability
Security Automation
DevSecOps Security Scanning
Practice adding automated security checks to a learning pipeline without presenting them as production security ownership.
Current experiments
- Running CodeQL analysis through GitHub Actions
- Using Trivy to scan a Docker image in the CI workflow
- Documenting what SAST and container scan findings can and cannot prove
Observability
Monitoring & Observability
Practice basic service visibility with Prometheus and Grafana before claiming production observability experience.
Current experiments
- Documenting Prometheus metrics and scrape concepts
- Building Grafana dashboard practice around learning-lab metrics
- Separating metrics evidence from broader logging and tracing claims
All Checkpoints
Each checkpoint is grouped by status so completed work, current practice, and planned study stay clearly separated.
Checkpoint • git-fundamentals
Git Fundamentals
Commit graphs, branching, and safe history
Get comfortable reading commit history and using branches without breaking shared work.
Objective
Get comfortable reading commit history and using branches without breaking shared work.
What I practiced
- Reading commit graphs with log --graph
- Interactive rebase to squash and reorder commits
- Resolving merge conflicts on feature branches
- Recovering lost commits with reflog
Validation
Rewrote a feature branch history locally, confirmed the graph looked correct, and verified the merge still passed my test script.
Key takeaways
- Interactive rebase is useful on local branches but risky on shared ones.
- Reflog saved me when I accidentally reset too far.
- Clear commit messages make debugging history much faster.
Commands
Checkpoint • linux-fundamentals
Linux Fundamentals
Shell, permissions, and system tooling
Build day-to-day fluency with Linux commands for server debugging and automation prep.
Objective
Build day-to-day fluency with Linux commands for server debugging and automation prep.
What I practiced
- Navigating and editing files from the shell
- Checking process status and system load
- Fixing permission issues with chmod and chown
- Reading service logs with journalctl
Validation
Ran a setup script on a fresh Ubuntu VM, fixed two permission errors, and confirmed the service started cleanly.
Key takeaways
- Permission errors show up constantly in deployment work.
- journalctl is faster than guessing where log files live.
- Small shell aliases save time on repeated commands.
Commands
Checkpoint • docker-intro
Docker
Images, containers, and local service composition
Package applications into containers and compose multi-service setups for local development.
Objective
Package applications into containers and compose multi-service setups for local development.
What I practiced
- Writing Dockerfiles with multi-stage builds
- Running containers with port mapping and volumes
- Composing multi-service apps with docker compose
- Inspecting container logs and health status
Validation
Built a multi-container app locally, confirmed service-to-service connectivity, and documented the compose file.
Key takeaways
- Multi-stage builds keep production images smaller.
- Health checks in compose catch startup failures early.
- Bind mounts are fine for dev; named volumes are better for persistent data.
Commands
Checkpoint • bash-scripting
Bash Scripting
Repeatable shell automation
Write shell scripts that automate setup checks and deployment prep with basic error handling.
Current experiments
- Refining small scripts for local environment checks
- Testing safe failure handling in shell workflows
- Documenting how I structure scripts for readability
Partial validation
The scripts run locally in a controlled environment, but I have not yet used them in a full deployment workflow.
Open problems
- Handling edge cases around missing files and permissions
- Making script output more useful when a step fails
Areas being refined
- Error handling and logging
- Reusable function structure
- Dry-run feedback for destructive steps
Checkpoint • ci-cd
CI/CD & Deployment Pipelines
Pipeline automation and validation
Automate build, test, and deploy steps with GitHub Actions so changes are verified before they ship.
Current experiments
- Setting up workflow triggers for push and pull request events
- Testing build and test stages with a small project layout
- Reviewing deployment scripts for failure handling
Partial validation
The workflow structure is running in a local learning repository context, but I am still refining the deployment and rollback steps.
Open problems
- Making tests more reliable and faster
- Separating build and deploy concerns more clearly
Areas being refined
- Workflow visibility
- Dependency caching
- Rollback safety
Checkpoint • devsecops-security-scanning
DevSecOps Security Scanning
CodeQL, SAST, and container image scanning
Practice adding automated security checks to a learning pipeline without presenting them as production security ownership.
Current experiments
- Running CodeQL analysis through GitHub Actions
- Using Trivy to scan a Docker image in the CI workflow
- Documenting what SAST and container scan findings can and cannot prove
Partial validation
The learning repository contains CodeQL and Trivy workflow evidence, but I am still refining how results should block or inform deployment decisions.
Open problems
- Deciding which findings should fail a pipeline
- Separating basic scan setup from deeper supply-chain security work
Areas being refined
- CodeQL workflow interpretation
- Trivy result review
- Security gates and deployment protection
Checkpoint • observability-basics
Monitoring & Observability
Metrics, dashboards, and runtime visibility
Practice basic service visibility with Prometheus and Grafana before claiming production observability experience.
Current experiments
- Documenting Prometheus metrics and scrape concepts
- Building Grafana dashboard practice around learning-lab metrics
- Separating metrics evidence from broader logging and tracing claims
Partial validation
The learning repository has Prometheus and Grafana checkpoints, but this is still local lab practice rather than production monitoring.
Open problems
- Adding clearer screenshots or dashboard exports
- Connecting logs, metrics, and alerts into one explainable workflow
Areas being refined
- Prometheus metric naming
- Grafana dashboard organization
- Evidence screenshots and dashboard exports
Checkpoint • database-infra-basics
PostgreSQL & Redis Foundations
Persistence, volumes, and caching basics
Practice database persistence and caching concepts as backend infrastructure building blocks.
Current experiments
- Documenting PostgreSQL persistence with Docker volumes
- Practicing Redis and caching foundations in the learning lab
- Connecting database infrastructure notes back to backend project needs
Partial validation
The checkpoints document the concepts, but I am still turning them into repeatable project-level examples.
Open problems
- Adding runnable examples that exercise persistence and cache behavior
- Documenting failure and recovery cases more clearly
Areas being refined
- Database volume behavior
- Cache invalidation basics
- Service dependency documentation
Checkpoint • networking-basics
Networking
TCP/IP, DNS, and service connectivity
Study how packets move between services and how to diagnose connectivity issues in containers and cloud setups.
Goals
Study how packets move between services and how to diagnose connectivity issues in containers and cloud setups.
Topics to explore
- TCP/IP packet flow and common port protocols
- DNS resolution paths and troubleshooting with dig/nslookup
- Container networking and service-to-service connectivity
- Firewall rules and basic network segmentation
Planned technologies
Future experiments
- Debug connectivity between two docker-compose services
- Trace DNS resolution for a deployed application
- Document a network troubleshooting checklist
Checkpoint • cloud-fundamentals
Cloud Fundamentals
Core services, IAM, and deployment models
Learn how cloud providers organize compute, storage, and identity so I can move applications beyond local containers.
Goals
Learn how cloud providers organize compute, storage, and identity so I can move applications beyond local containers.
Topics to explore
- Cloud service models (IaaS, PaaS, SaaS) and when each fits
- IAM roles, policies, and least-privilege access
- Compute and storage options for containerized apps
- Cost monitoring and resource tagging basics
Planned technologies
Future experiments
- Deploy a containerized app to a cloud provider free tier
- Set up IAM roles with least-privilege access
- Compare deployment costs between two cloud services
Checkpoint • kubernetes
Kubernetes
Pods, services, and configuration
Understand how Kubernetes orchestrates containers so I can move from docker compose to cluster-based deployments.
Goals
Understand how Kubernetes orchestrates containers so I can move from docker compose to cluster-based deployments.
Topics to explore
- Pod lifecycle and deployment manifests
- Services, ingress, and cluster networking
- ConfigMaps and Secrets for configuration management
- Basic kubectl debugging and log inspection
Planned technologies
Future experiments
- Deploy a multi-service app to a local Kubernetes cluster
- Configure health checks and resource limits on pods
- Document a kubectl troubleshooting workflow