DevOps · DOP-10

DevOps for Full Stack Developers

DevOps for Full Stack Developers is a hands-on course in taking FastAPI and Vue.js applications to Kubernetes from the developer's side, from Docker containers and GitLab CI/CD pipelines with GitLab Runner to Helm deployments with the Gateway API, review apps and rollback. It suits full-stack developers and tech leads who want to deploy their own work without waiting on operations.

Updated 20 Oct 2026

From 8,910 THB / person 9,900 −10% excl. VAT 7% · group rates available

Corporate training quote Join the waiting list

PDFDownload the course outline

Duration24 hours · 4 days
FormatOnsite / live online
Next roundOn request
CertificateIncluded

Course overview

Development teams are expected to ship software faster and more often, so full-stack developers are no longer responsible only for writing code. They need to understand how their code is built, tested and deployed to Kubernetes. The usual problems are code that runs on a laptop but fails in the target environment, slow and fragile pipelines, and developers who must wait for the operations team every time they want to deploy.

This course takes the developer's point of view. Learners package a FastAPI backend and a Vue 3 and Vite frontend as containers with Docker, build automated pipelines with GitLab CI/CD and GitLab Runner, store images in the GitLab Container Registry, and deploy to Kubernetes with Helm 4 and the Gateway API, complete with environments, a review app for every merge request and rollback. Everything is built up on one project, the PulseDesk Service Portal, until learners have a reference pipeline where a push takes the system all the way to Kubernetes. (4 days, 6 hours per day, 24 hours in total, Intermediate level.)

What you’ll gain

Understand DevOps and the developer's role in the build, test, release and deploy cycle
Package FastAPI and Vue.js applications as small, secure, production-ready container images
Write well-structured .gitlab-ci.yml files that use caches, artifacts, rules and needs appropriately
Install and register GitLab Runner and choose the right executor for the job
Write the Kubernetes manifests developers need and expose services with the Gateway API
Use Helm 4 to manage deployments across several environments
Build a pipeline that deploys to Kubernetes automatically, with environments, review apps and rollback

Who this course is for

Full-stack developers working in Python and JavaScript or TypeScript who want to deploy their own work
Backend or frontend developers whose team is moving its systems to Kubernetes
Tech leads who want to set pipeline standards for their development team
Teams already on GitLab who want to get the most out of GitLab CI/CD

Prerequisites

Basic Python and experience with at least one web framework
Basic JavaScript or TypeScript
Git (branches, commits, pushes and merge requests) and basic Linux command-line skills
A laptop with 16 GB RAM or more (32 GB recommended) and administrator rights, plus a gitlab.com account or an account on your organisation's GitLab

Curriculum

Course Details

This course takes the view of an application team that has to get its own code onto Kubernetes through GitLab CI/CD. It runs for 4 days, 6 hours per day (24 hours in total, 09:00-16:00), as a continuous workshop on the PulseDesk Service Portal, a fictional internal IT help desk that uses only sample data. Intermediate level. Starter code for the FastAPI and Vue.js apps is provided, so most of the time goes into DevOps work. Learners use a gitlab.com account

or their organisation's GitLab, and run the runner and Kubernetes on their own laptops. Sibling courses published alongside it are Enterprise CI/CD with GitLab, Jenkins and Kubernetes, which takes the platform team's view and covers Jenkins and SonarQube, and Docker in Practice for those who want to go deeper into Docker. Production cluster administration, service mesh, a full monitoring stack and GitOps with Argo CD are out of scope. Learners take home the lab guide, starter code, .gitlab-ci.yml files, manifests and Helm charts.

Day 1 DevOps Foundations and Containerising FastAPI and Vue.js

Section 1: DevOps for Developers

The plan, code, build, test, release, deploy, operate and monitor cycle
Twelve-Factor App principles that make an app ready for containers and Kubernetes
How continuous integration, continuous delivery and continuous deployment differ
The developer's role and the platform team's role in getting code into production

Section 2: Lab: Getting to Know PulseDesk

The FastAPI project structure and dependency management with uv
The Vue 3.5 and Vite 8 project structure and setting the API URL through the environment
Health endpoints, reading configuration from environment variables and structured logging
Lab: run the app locally and walk a test ticket through the whole flow

Section 3: Lab: Containerising FastAPI

A multi-stage Dockerfile for Python and choosing a slim base image
Running as a non-root user and configuring Uvicorn for production
Using .dockerignore and layer caching for faster builds
Lab: build the pulsedesk-api image and compare its size before and after optimising

Section 4: Lab: Containerising Vue.js

Building static files with Vite and serving them with Nginx
Configuring Nginx for an SPA in history mode and proxying requests to the API
Runtime frontend configuration instead of rebuilding for every environment
Lab: build a pulsedesk-web image that works unchanged in every environment

Section 5: Workshop: Docker Compose for Local Development

Combining the API, web app and PostgreSQL 18 in one Compose file with health checks and volumes
Running migrations and seeding sample data at start-up
Fixing common problems such as a service starting before the database is ready
Workshop: start the whole of PulseDesk with one command and test the full flow

Day 2 GitLab CI/CD and GitLab Runner

Section 6: GitLab CI/CD Fundamentals

The structure of .gitlab-ci.yml: stages, jobs, script, image and variables
Branch pipelines, merge request pipelines and tag pipelines
Controlling execution with rules and workflow
Lab: the first PulseDesk pipeline, triggered on push and on merge requests

Section 7: Lab: GitLab Runner

Runner architecture and instance, group and project runners
Creating a runner in the UI and registering it with a runner authentication token
Shell, Docker and Kubernetes executors compared, and choosing between them with tags
Lab: register a Docker executor runner on your own laptop

Section 8: Fast, Maintainable Pipelines

Caches for Python and Node.js dependencies, and artifacts for passing results between jobs
needs for running jobs as a DAG instead of waiting for whole stages
Reducing duplication with extends, include and CI/CD components
Lab: measure pipeline time before and after adding caches and needs

Section 9: Lab: Testing and Quality in the Pipeline

Running pytest and Vitest and reporting test results on the merge request
Showing coverage on the merge request
Lint and format checks for both Python and JavaScript
Lab: block merge requests whose tests fail

Section 10: Lab: Building, Scanning and Pushing Container Images

Building images in the pipeline with Docker-in-Docker or Buildah, and the security caveats
Pushing to the GitLab Container Registry with predefined variables
Tagging by commit SHA and version
Scanning with Trivy and failing the pipeline on high-severity vulnerabilities
Workshop: a PulseDesk pipeline that lints, tests, builds, scans and pushes both images

Day 3 Kubernetes and Helm for Developers

Section 11: Lab: The Kubernetes Developers Need

Cluster architecture in brief and working with kubectl
Pods, deployments, ReplicaSets and services
Preparing a lab cluster with kind or k3d
Lab: deploy pulsedesk-api with manifests you write yourself

Section 12: Configuration, Secrets and Health Checks

ConfigMaps and Secrets for FastAPI and Vue.js configuration
Liveness, readiness and startup probes that match the app's health endpoints
Resource requests and limits and their effect on scheduling
Lab: add probes and resources to PulseDesk and watch what happens when the app is not ready

Section 13: Lab: Exposing Services with the Gateway API

Why move away from Ingress: Ingress NGINX has been retired since March 2026
Gateway and HTTPRoute, and defining paths for the web app and the API
Installing a Gateway controller in the lab cluster
Lab: open PulseDesk to users through the Gateway API

Section 14: Databases and Stateful Workloads

Choosing between PostgreSQL outside the cluster and running it in the cluster for labs
PersistentVolumeClaims and keeping data persistent
Running migrations as a Kubernetes Job before releasing a new version
Lab: run the PulseDesk migrations as a Job

Section 15: Lab: Helm 4 for Developers

Chart structure, templates and values
Separate values per environment: dev, staging and production
install, upgrade and rollback, and key changes in Helm 4 such as server-side apply
Workshop: turn the PulseDesk manifests into a Helm chart and deploy it to the cluster

Day 4 Continuous Deployment to Kubernetes and Master Workshop

Section 16: Lab: Connecting GitLab to Kubernetes

The GitLab agent for Kubernetes and giving pipelines secure access to the cluster
Using the Kubernetes executor so runner jobs run as pods in the cluster
Handling pipeline secrets with masked and protected variables
Lab: install the agent and make the first Helm deployment from the pipeline

Section 17: Environments and Deployment Strategy

GitLab environments for staging and production
A manual job before production, and an overview of protected environments
Kubernetes rolling updates and readiness checks before taking traffic
Lab: deploy to staging automatically and to production on confirmation

Section 18: Lab: Review Apps for Every Merge Request

A dedicated namespace and URL for each merge request
Removing the review app automatically when the merge request is merged or closed
Letting reviewers try new features before merging
Lab: open a merge request and get a PulseDesk review app straight away

Section 19: Rollback and Post-deployment Checks

Rolling back with Helm and by redeploying the previous image version
Smoke tests after deployment
Reading Kubernetes logs and events to find the cause of a problem
Lab: release a version whose probes fail and see how a rolling update protects the system

Section 20: Master Workshop: A Pipeline from Commit to Production

Design the complete PulseDesk pipeline: test, build, scan and deploy with Helm
Automatic staging, a review app per merge request and production on confirmation
Simulate a bad release and roll back within a set time
Present the team's pipeline and plan how to apply it to real projects

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

Join the waiting list Ask about rounds

For organisations — in-house / private

Tailor the content to your team’s tools and projects
Your dates, at your office or live online
Quotation with tax ID for procurement

Corporate training quote

Instructors

Samit KoyomFounder & CEO, IT Genius Engineering

Frequently asked questions

How does this course differ from Enterprise CI/CD with GitLab, Jenkins and Kubernetes and CI/CD with Jenkins?

This course takes the application team's view: getting your own FastAPI and Vue.js apps onto Kubernetes with GitLab CI/CD and GitLab Runner. Enterprise CI/CD with GitLab, Jenkins and Kubernetes, published alongside it, takes the platform team's view of organisation-wide pipelines with GitLab, Jenkins and SonarQube, and CI/CD with Jenkins (5 days) focuses on Jenkins itself. If you are not yet comfortable with Docker, take Docker in Practice or Basic Docker first.

Do I need a paid GitLab plan, and does the institute provide accounts?

The institute does not provide accounts or licences. You use your own free gitlab.com account or an account on your organisation's self-managed GitLab. The core labs use features available on the free tier, with the runner on your own laptop. Features that need Premium or Ultimate, such as protected environments and GitLab's built-in security scanning, are covered as an overview, and the open source Trivy is used instead.

I have never used Kubernetes or Helm. Can I join?

Yes. Day 3 covers Kubernetes from the developer's side, from pods, deployments and services to probes and Helm, using a cluster created on your laptop with kind or k3d. Installing and running production clusters, which is the platform team's job, is not covered in depth.

How well do I need to know FastAPI and Vue.js?

You do not need to be an expert. Full starter code for the PulseDesk backend and frontend is provided, and the course does not teach the frameworks; most of the time goes into containers, pipelines and Kubernetes. You should be able to read basic Python and JavaScript and be comfortable with Git.

How should I prepare my laptop?

You use your own laptop with at least 16 GB RAM (32 GB recommended), at least 4 CPU cores and about 50 GB of free disk space. Install Docker Desktop (with WSL2 on Windows) or Docker Engine, Git, VS Code, kubectl, Helm and kind or k3d before the course. You need administrator rights and access to GitLab, Docker Hub, PyPI and the npm registry.

Does the course cover GitOps with Argo CD or monitoring?

No. This course deploys with Helm through the GitLab agent for Kubernetes directly from the pipeline. GitOps with Argo CD, service mesh and a full monitoring stack are out of scope. For organisation-wide pipelines, continue with Enterprise CI/CD with GitLab, Jenkins and Kubernetes, and for deeper Kubernetes skills, Kubernetes (K8s) Orchestration.