Cloud-native learning path: 90-day plan

Learning cloud-native skills from random YouTube playlists produces tutorial hell—you can kubectl get pods but cannot ship a service your team trusts. DarDevLab's 90-day path sequences containers, Kubernetes, CI/CD, and observability with labs that mirror production constraints we use on dardev-vps and client clusters.

This plan suits developers and DevOps engineers in Tunisia and MENA with basic Linux comfort. Expect 8–10 hours per week including hands-on labs, not passive video watching.

Days 1–30: Containers and delivery basics

1. Week 1: Linux processes, cgroups, Docker images and multi-stage builds
2. Week 2: Compose for local multi-service apps (API + Postgres + Redis)
3. Week 3: Networking, volumes, health checks,.dockerignore discipline
4. Week 4: Ship a small API container to a VPS with manual deploy runbook

Milestone: one containerized app running on a remote host with documented rollback—not just localhost docker run.

Days 31–60: Kubernetes fundamentals

1. Week 5: Pods, Deployments, Services, ConfigMaps, Secrets
2. Week 6: Ingress, TLS, resource requests/limits
3. Week 7: Helm or Kustomize for repeatable manifests
4. Week 8: Debugging: logs, describe, events, port-forward

Days 61–90: CI/CD and observability

1. Week 9: GitLab CI pipeline—test, build image, deploy to staging
2. Week 10: Prometheus metrics and Grafana dashboards for your app
3. Week 11: Alert routing basics—not paging for every blip
4. Week 12: Capstone: deploy + monitor + document runbook

Capstone project replaces certificate vanity: a reviewer should deploy your repo from README, see metrics, and roll back a bad image tag.

How DarDevLab supports the path

Instructor-led cohorts at dardevlab.com add code review and demo days; self-paced tracks suit night learners but need discipline buddies. Certification tracks validate shipped projects, not multiple-choice trivia.

Anti-patterns to avoid

• Skipping containers and jumping straight to Kubernetes YAML copy-paste
• No git history on lab work—lost evidence for employers
• Cluster-admin CI tokens for convenience
• Collecting courses without one repo that evolves 90 days straight

Pair this plan with our tutorial-hell-to-shipped-project and kubernetes-fundamentals-lab articles for deeper dives on specific weeks.

Study habits that stick

Block two focused sessions weekly instead of cramming weekends. Keep one monorepo lab-project that grows each week—employers review git history, not course completion badges.

Find a peer or cohort mate for demo days: explaining your deploy runbook aloud exposes gaps reading tutorials hides.

After day 90, specialize: GitOps track, observability depth, or platform security—breadth first, then one vertical aligned with job targets.

DarDev hires and recommends engineers who ship; this path mirrors how our platform team onboards internally before client-facing work.

Weekly time budget (sample)

• 3 hours: hands-on lab exercises
• 2 hours: reading official docs (Kubernetes, Docker, GitLab)
• 2 hours: extending capstone repo
• 1 hour: cohort call or peer review if enrolled

Skip weeks without output in git—you should see commits or tagged releases every seven days minimum during the 90-day window.

Tunisia and MENA learners often balance day jobs; adjust timeline to 120 days rather than quitting when a single week slips. Consistency beats intensity.

After capstone, contribute one internal doc at your employer or one public blog post explaining a failure you fixed—teaching solidifies retention better than collecting certificates.

Week 12 capstone demo should include failure injection: kill a pod, restore from backup, show metric alert firing—employers trust operators who rehearse incidents.

Link your capstone README from LinkedIn with three bullets: problem, stack, proof URL—recruiters skim; make outcomes scannable.

Recommended reading per month

• Month 1: Docker docs, Twelve-Factor App summary
• Month 2: Kubernetes documentation core concepts
• Month 3: GitLab CI reference, Prometheus getting started

Avoid collecting alternate courses mid-month—depth on one stack beats sampling five platforms superficially.

DarDevLab instructors align cohort milestones to this 90-day skeleton but adjust pacing for enterprise clients with on-call rotations.

Finish day 90 with a written postmortem: what shipped, what broke, what you would teach differently to the next learner on your team.

Budget for failed experiments: broken pipelines and redeploys are learning, not waste, if you document fixes in the capstone runbook reviewers can follow.

Join DarDevLab office hours when stuck more than two hours on one error—community unblock beats silent struggle and keeps the 90-day timeline realistic.

Track hours spent versus milestone delivered; if week six Kubernetes labs exceed ten hours without working Deployment, ask for instructor help rather than falling behind silently.

Alumni often revisit month-one Dockerfiles in month three—layer caching and image size matter once CI runs every push.

Publish capstone demo video under five minutes—reviewers watch intro and rollback section; keep deep YAML walkthrough in README appendix.

Ninety days is a floor, not a ceiling; many DarDevLab learners continue into GitOps and observability specialty tracks immediately after capstone review.

Screenshot your Grafana dashboard and CI green build on day 90—visual proof complements README for hiring managers skimming portfolios.

Share the repo link in your DarDevLab cohort channel for feedback before calling the path complete.