
Explore docker fundamentals, Linux basics, container and image concepts, Dockerfile and docker-compose workflows, and deploy a full stack TypeScript project with Nginx, PostgreSQL, and Redis.
Navigate a dockerized Ubuntu shell and master 10 essential Linux commands—pwd, ls, cd, clear, cat, mkdir, rm, tab completion, and history recall—to cover 90% of server work.
Learn to manage files and permissions in Docker containers to support reliable production deployment for developers.
Pack your application and its environment into a Docker container to guarantee the same behavior from laptop to test server to production.
Explore what a container is by running an nginx container with Docker run, and learn that containers are isolated processes, not virtual machines, -d, -it, and pulling from Docker Hub.
Learn the container life cycle by running in detach mode, naming containers, and mapping host ports (e.g., 8081 to 80), manage with docker ps, logs, start, stop, restart, and remove.
Learn how Docker image naming, tagging, and sharing work, including registry, username, and tag semantics, and how to pull, tag, and push images with proper authentication for production.
Clean up docker resources by removing stopped containers, unused images, and volumes, and clearing build cache using docker rm, docker container prune, docker image prune, and docker system prune.
Review core docker concepts, including containers, container life cycle, images, volumes, and networking, to reinforce practical deployment skills from zero to production.
Learn how a Dockerfile acts as a receipt that Docker follows to produce the same image every time, with predictable and remittable results for your app.
Explore how the build context governs what files Docker sends to the engine, and how the .dockerignore file excludes large folders like node_modules and git to speed up builds.
Optimize Docker builds by ordering Dockerfile instructions to maximize layer caching, placing rarely changing steps above frequently changing code, and copying bucket.json and bucket lock.json before npm install.
Explains the roles of run, cmd, and entrypoint; shows build time vs run time, how npm install adds image layers, and that cmd is overrideable while entrypoint is not.
Learn to run a container as a non-root by using the node user, preventing root access on the host and improving production security.
Recap of docker compose basics: define services, use service names for networking, pass environment variables, add health checks, and use local compose for development.
Review the fundamentals of Nginx, including using ByteMouse with files and writing effective Nginx configurations. Prepare to apply these skills to a real-world project in the next session.
Explore the deploy flow architecture and production stack, including Next.js frontend, Express backend, BullMQ worker, Postgres, Redis, and Nginx, with Docker Compose and routing.
Create docker files for the web and a worker, install dependencies with npm, build the Next.js app on node.js, run in production, and configure nginx to proxy the API.
Learn to write a docker-compose.yaml for a Postgres service, configure environment vars, volumes, and health checks, and understand service naming and .env placeholders.
Learn how to configure a docker compose workflow for a worker and a web service, set up environment and health checks, map ports, and ensure api health for production deployment.
Explore how to share a docker network across multiple apps with an edge gateway strategy, using an external web gateway network, nginx config, and joined docker compose setups.
Initialize the database by mapping init.xql and running the one-time db init; connect with vsql to the notification database, then remove the postgres data volume to reinitialize.
Create a non-root deploy user, add to the sudo and docker groups, and update the system to prep for docker deployment.
Set up a domain for deployment by buying a domain from a provider such as Cloudflare or Namecheap, then configure DNS records with your VPS IP and enable proxying.
Set up TLS with certbot to enable HTTPS in a docker environment, configure nginx and a support service, use ACME challenge for TLS renewal every 10 hours.
Tired of Docker tutorials that stop at "hello world"? This course is built for developers who want to actually ship, not just understand containers in isolation.
By the end of this course, you'll have deployed a multi-service application to a real server, accessible at your own domain over HTTPS. Not a toy project, a real-world stack with a Next.js frontend, Express API, BullMQ worker, Postgres, Redis, and nginx as a reverse proxy.
This course is designed for working developers — not DevOps engineers, not SREs, not infrastructure specialists. If you write code for a living and want to understand the deployment side of your job, this is for you.
You should know:
- A backend language (Node.js examples, but concepts transfer)
- Basic command line
- What HTTP, JSON, and a database are
You don't need to know:
- Linux administration
- Networking deep-dives
- Kubernetes or any orchestration
- Production operations theory
WHAT YOU'LL BUILD
You'll containerize and deploy a real multi-service application with:
- Next.js frontend rendering pages
- Express API serving data
- Background worker processing jobs (BullMQ)
- PostgreSQL for persistent storage
- Redis for caching and job queues
- nginx as a reverse proxy with HTTPS
- A shared edge gateway pattern for hosting multiple projects on one server
By the final lesson, your app will be live at your own domain with a real TLS certificate from Let's Encrypt.
WHAT MAKES THIS COURSE DIFFERENT
Most Docker courses teach you what containers ARE. This course teaches you how to USE them in your daily work. Every lesson is anchored in a real problem you'll hit on the job.
- Pain-driven explanations: every concept starts with a problem you'd actually encounter, not a feature list.
- Practical-first: no Kubernetes, no theory dumps, no abstract architecture. You'll write Dockerfiles and Compose files for real apps from lesson one.
- Honest about tradeoffs: when there are multiple ways to do something, you'll see them all and learn when each fits.
- Real production deployment: the course ends with your app live on the internet, not on localhost.