Skip to content
devopssyscourse.org
tracks/developer
DEV · Developer

Write software that survives production.

For people starting as developers and for developers who want to own what they ship. Language and framework are chosen per cohort. The engineering habits are the same everywhere.

who

Who this track is for

  • Career switchers with some coding exposure who want a first developer job
  • Junior developers who have never run their own code in production
  • Developers who inherited the build, deploy and monitoring and want to understand it
  • Testers, analysts and support engineers moving into development
levels

Three entry levels

Profiling places you on one. The cohort is built from people on the same level with the same target, so the plan is never too slow for half the room.

  1. level 1

    Foundations

    you are
    You have written some code in courses, scripts or personal projects, but never worked in a team codebase.
    you get
    A working developer: Git workflow, tests, code review, a deployed capstone and a portfolio you can explain in an interview.
  2. level 2

    Working developer

    you are
    You ship features, but deploys, pipelines and incidents happen to you rather than by you.
    you get
    You own your service end to end: CI, containers, observability and safe releases.
  3. level 3

    Senior / lead

    you are
    You lead features or a small team and want to raise the engineering bar.
    you get
    You set the standard: architecture decisions, review culture, reliability and security built into delivery.
plan

What a typical plan covers

10 modules in the order a typical cohort runs them. Your cohort's plan is cut, extended and re-ordered after profiling, and names the exact tools.

  1. Working in a team codebase

    01
    • Git branching and pull requests
    • Code review that improves code
    • Trunk-based development, conventional commits
  2. Language core (chosen per cohort)

    02
    • TypeScript/Node.js, Python or Go
    • Project structure, packaging, idioms
    • Reading unfamiliar code fast
  3. HTTP, APIs and data

    03
    • REST and JSON, auth basics
    • PostgreSQL, migrations
    • ORMs versus SQL, when each
  4. Testing that pays off

    04
    • Unit, integration and contract tests
    • Test data and fixtures
    • Coverage that matters versus coverage theatre
  5. CI for developers

    05
    • GitHub Actions or GitLab CI pipelines
    • Linting, build matrices, caching
    • Pipelines as code review
  6. Containers for developers

    06
    • Dockerfiles and multi-stage builds
    • Compose for local environments
    • Image hygiene and size
  7. Observability for developers

    07
    • Structured logs, metrics, traces with OpenTelemetry
    • Reading dashboards during an incident
    • Instrumenting your own service
  8. Secure coding

    08
    • OWASP Top 10 in practice
    • Secrets, dependencies, input validation
    • Fixing findings from a scanner
  9. Shipping safely

    09
    • Environments and feature flags
    • Zero-downtime migrations
    • Rollbacks you have rehearsed
  10. Capstone

    10
    • Build, test, containerise, deploy and monitor a service
    • Present it to the mentor panel
    • Portfolio write-up
tools

Tools you will work with

  • Git
  • GitHub / GitLab
  • Docker
  • PostgreSQL
  • GitHub Actions
  • OpenTelemetry
  • Grafana
  • TypeScript / Node.js
  • Python
  • Go

The final list is set in the cohort plan. Where the market is split, such as cloud providers, the cohort picks the one most of its members need.

outcomes

By the end, you can

  1. Ship a change from branch to production with tests, review and a rollback plan
  2. Build and run your service in containers locally and in CI
  3. Read logs, metrics and traces to find your own bug in production
  4. Explain your capstone in a technical interview, line by line
example

Ten people, TypeScript, 12 weeks

Four career switchers, five juniors and one tester moving into development. The plan was built around a TypeScript/Node.js stack because that is what their target employers use. Two guest sessions on PostgreSQL were added after profiling showed a gap across the whole group.

Illustrative cohort, built from the typical mix for this track.

Tell us where you want to get to.

Applying takes five minutes. Profiling is free and you keep the skills map. The cohort, the plan and the price come before any commitment.

Cohorts are forming now for all four tracks. We reply within two working days.