Host your apps and internal tools with Dokploy and Tailscale. Learn the deployment and recovery workflow, then use your AI agent to help repeat it.
Trusted by 9,700+ engineers
Most of the course is ready to watch. A few smaller lessons are being re-recorded.
The tools you will use
Hetzner
Docker
Dokploy
Tailscale
PostgreSQL
.NET
Redis
GitHub Actions
Cloudflare R2
UptimeRobot
Your instructor
I'm a Microsoft MVP and software architect with 10+ years of experience. I teach .NET and software architecture.
I build and self-host Katabench, a .NET coding platform with a few thousand users. I also run my internal tools and observability platform on Dokploy.
This course teaches the infrastructure patterns I use myself. You will practice on TaskFlow, an app built for the deployment and recovery exercises.
But first come the hosting decisions, the scattered tutorials, and the worry about what happens when something breaks.
The architecture you will build
Follow the private access, deployment, request and recovery paths. Each view connects the tools to the job they do together.
One server is one failure domain. You will learn its limits alongside its deployment and recovery workflow.
The workflow you practice
Follow a release from source code to a running app. Then rehearse the recovery steps while you are learning, with a disposable practice app.
01 · Release
Test and build once. Record the image identity, then deploy through the private API.
02 · Verify
Match the live commit to the release. Inspect readiness and prove that an application write persists.
03 · Recover
Roll back the application release. Separately, restore a database backup into a temporary database.
The Foundations curriculum
Provision, harden, go private, deploy, automate, back up, and maintain. Modules 0–9 cover the full process. The included AI companion shows how to use the supplied skills when you repeat the work.
Free Preview
See what you will build and what you need to get started. No signup required.
Select a lesson, then press play.
Module 0 · Start here
Source code and course materials are included with enrollment.
Get the complete courseSee when self-hosting can lower infrastructure costs, give you more control over performance, and let you choose your own stack. Tour the finished TaskFlow application and the architecture you will build, including private administration, automated deployments and recovery. Get clear on the tools, accounts and prior knowledge you need before starting the practical lessons.
Compare the convenience of managed hosting with the cost and responsibility of running a VPS. See what the provider, Docker and Dokploy each handle, how Dokploy compares with alternatives such as Coolify, and which operating tasks remain yours. Use those tradeoffs to decide whether this setup suits your application.
Provision an Ubuntu server on Hetzner with SSH access and a cloud firewall configured from the start. Create a passphrase-protected SSH key, upload only its public half, and restrict the initial SSH connection to your IP address. Connect from your workstation and verify the server before changing its security settings.
Replace routine root access with a dedicated deploy user and key-based SSH authentication. Disable root and password login, check the settings SSH actually applies, and test a second connection before closing the first. Bring the server up to date, enable automatic security updates, and understand where tools such as UFW and fail2ban fit.
Connect your computer and server with Tailscale, and understand how its private network separates administration from public app traffic. Move SSH onto that network, remove the public SSH firewall rule, and verify that private access still works. Learn the recovery route through the provider console and where alternatives such as Headscale and Cloudflare Tunnel fit.
Understand how images, containers and Docker Compose fit together, then install Dokploy and reach its panel through Tailscale. Set up your administrator account and two-factor authentication, and check that the panel cannot be reached over the public internet. Get familiar with projects, services, domains and deployments so you can configure the application in the next module.
Deploy TaskFlow, the supplied React and .NET app, with PostgreSQL and Redis. Configure DNS, registry access and secrets, then use Traefik for automatic HTTPS while the database and cache stay private. Stop PostgreSQL in Dokploy to see the difference between liveness and readiness, then bring it back and verify that the app recovers and your data persists.
Follow a GitHub Actions workflow that tests the app, builds a Docker image and publishes it to GHCR with a commit SHA tag. Give the runner temporary Tailscale access to call the private Dokploy API, then verify which commit is running. Inspect database migrations through an SSH tunnel and practice rolling back to an earlier application image.
Identify what needs backing up, including application data and Dokploy configuration. Set up Cloudflare R2 with bucket-scoped credentials and verify that both backup types reach storage outside your VPS. Restore a specific database backup into a temporary database, compare its schema and row counts, and confirm that the live application data remains unchanged.
Set up UptimeRobot to check your public readiness endpoint and send test outage and recovery notifications to your chosen alert channel. Build a monthly routine for backups, server resources and updates, with checks after each change. Consider Uptime Kuma as a self-hosted monitoring alternative, and learn which measurements help you decide when to resize or move beyond one server.
Learn how the seven included skills help Claude Code, Codex, Cursor or GitHub Copilot repeat the workflows you have practiced. See what each skill does and how to supply the relevant app details. Walk through release-check on TaskFlow, compare the expected and running commits, and review the results so you can use the skills on your own deployments.
Follow the lessons at your own pace. Allow additional time for hands-on setup, deployments, and recovery practice.
Another use for your server
This year, I built and self-hosted replacements for tools I used to pay for. The same deployment foundation supports my apps and the tools I use to run my business.
Testimonials
$590/year
Testimonials
Built for my own workflow, hosted on my infrastructure
Transcription
$120/year
Transcriptions
A focused tool I can run and maintain myself
$710/year
In subscriptions I replaced
$590 for Senja + $120 for TurboScribe. This is the annual subscription cost I can avoid, before hosting, API usage, and maintenance. Your savings depend on the tools you replace.
I built Transcriptions for my recordings, transcripts, and course subtitles. It runs on a VPS I already pay for, with a speech-to-text API behind it.
That is a $120 annual renewal I can avoid. API usage, hosting, and maintenance still have a cost.
Read the full breakdown
Your AI agent, with the right context
The included Working with agents lesson covers all seven skills and a release check on TaskFlow. Give your agent the instructions and app details, then review what it finds.
Use the skill files with Claude Code, Codex, Cursor, or GitHub Copilot.
“Use release-check and my app details. Check whether this release is live. Show the expected and running commits, readiness, and workflow result. Tell me what you could not check. Do not change the app.”Keep these details in a note you can reuse. Your agent uses its configured access. Credentials stay out of the note.
preflightReview prerequisites, environment details, and missing context before changing anything.
private-accessCheck private connectivity and the recovery path before closing an existing access route.
deployAdapt the taught pipeline, deploy through the private API path with your approval, and verify the live commit and readiness.
release-checkCompare the intended commit with the running app, its readiness, and the workflow result.
diagnoseStart with symptoms and read-only evidence. Separate likely causes from verified facts.
scratch-restoreIdentify the backup and an isolated restore target, then verify the result against your receipt.
maintenanceReview updates, capacity, backup freshness, and alerting against the same checklist.
What is included
Watch the lessons. Follow the runbook. Keep the source and skills for the next deployment.
Modules 0–9 cover the single-server workflow. The included Working with agents companion shows how to use the supplied skills.
Commands, expected results, deployment checklists, and recovery steps you can keep beside your terminal.
An MIT-licensed .NET and React practice app with PostgreSQL and Redis, ready for deployment exercises.
A reusable pack for preflight, private access, deployment, release checks, diagnosis, backup testing, and maintenance.
Can run a Docker container, use Git, and read terminal commands. Want to host a side project, a small SaaS, or an internal tool and take responsibility for operating it.
Practice deploying and operating applications on one server, with planned maintenance windows. TaskFlow is a disposable practice app. Use sample data.
Get the course
Learn the complete workflow and keep the source, runbook, and skills for your next deployment.
Foundations course
Launch priceOne-time payment. Lifetime access and updates.
Pre-release access. Most of the course is ready to watch. A few smaller lessons are being re-recorded.
VPS, domain, and third-party costs are separate.
Letter for your bossNeed approval? Copy a ready-made request for your manager.Questions before you start?
Most of the course is ready to watch. A few smaller lessons are being re-recorded.
Running your own applications requires understanding how server access, networking, containers, deployments, backups and monitoring work together. Foundations teaches those skills through a complete setup you build and operate yourself. You will understand the decisions behind your infrastructure and practice keeping it running, including recovering when something goes wrong.
Yes. Private administration is part of the foundation. You use Tailscale for SSH and the Dokploy panel, and for the CI runner to reach the deployment API. The application itself remains public over HTTPS.
Expect approximately 4 hours of video across Modules 0–9 and the included Working with agents companion. The current edit is around 4.5 hours, with further editing expected to bring it closer to 4 hours. Allow additional time for hands-on setup, deployments and recovery practice.
The included TaskFlow practice app uses .NET, React, PostgreSQL, and Redis. The principles transfer to other containerized apps, but adapting your Dockerfile, health checks, configuration, migrations, and backups is real engineering work. This course uses one focused reference application throughout.
You should be able to run a Docker container, use Git and GitHub, and read terminal commands. No prior Dokploy or Linux administration experience is assumed. The demonstrated local workflow uses PowerShell on Windows, with Bash after connecting to Ubuntu.
You learn and perform the workflow first. The included Working with agents lesson explains all seven skills and demonstrates a release check using your app details. Use the files with Claude Code, Codex, Cursor, or GitHub Copilot to help repeat the work. You provide the access it needs and review the results.
The course is a one-time purchase. A VPS and a domain are separate, and API services may charge for usage. Provider plans, IPv4 charges, taxes, and third-party service limits vary. The course explains the running costs and how to evaluate them for your own setup.
Multi-server deployments, separate staging environments and advanced observability are outside the course. You will build and operate a complete single-server setup and learn how to recognize when it is reaching its limits.
Deploy your app with Dokploy, keep administration private with Tailscale, and learn how to verify releases and recover your data.
Get instant accessIncludes the source code, Production Runbook, and all 7 agent skills.