6 min read
My tech stack in 2026: what I use to build and run my products
Python and Django on the backend, Next.js or HTMX on the front, PostgreSQL for data, and one server running Docker Swarm behind Traefik. The tools I use to build my products alone, why I picked them, and what I deliberately leave out.
- Tech stack
- Python
- Django
People sometimes ask what I build my products with. The short answer: Python and Django on the backend, Next.js or HTMX on the front, PostgreSQL for the data, and one server running Docker.
The longer answer is this article: every layer, why it's there, and what I chose not to use.
The rule behind the stack
I build my products alone, next to a full-time job as an IT consultant. That one fact decides almost everything:
- Few tools, used everywhere. Every project uses the same backend, the same database and the same deployment. When I switch from one product to another, I don't switch mental models.
- Boring beats new. I pick tools with years of documentation, answered questions and known failure modes. My products are where I want the surprises, not my infrastructure.
- One person must be able to run it. If a part of the stack needs a team to operate, it's the wrong part.
Backend: Python and Django
I have been writing Python since 2015, and it's the language I think in. For web products, I use Django almost every time, with Django REST Framework when a separate frontend or a mobile app needs an API.
Django gives me the ORM, migrations, authentication, the admin, forms, a test runner and management commands in one package that is designed to work together. I explained in detail why I chose it over Flask and FastAPI for Scoreboards in a separate article.
A few libraries come back in almost every project:
- djoser and SimpleJWT, or django-allauth, for accounts and login.
- drf-spectacular to generate the OpenAPI documentation from the code.
- Celery with Redis for background jobs: emails, reports, notifications, anything that shouldn't make a user wait.
- Django Channels when something must update live. On Scoreboards, goals and cards reach the match page over a websocket while the match is played.
- Stripe for payments and subscriptions.
FastAPI and Flask are still in my toolbox. I reach for FastAPI for a small service in front of a model or another API, where async and raw speed matter more than an admin and a data model.
Frontend: Next.js, or no JavaScript framework at all
I use two approaches, depending on what the page has to do.
Next.js, React, TypeScript and Tailwind CSS for public sites and rich interfaces. This website is a Next.js app, the Scoreboards public site and administration are two Next.js apps, and so are the landing pages of my newer products. Server rendering gives search engines real HTML, and TypeScript catches the mistakes I would otherwise find in production.
Django templates with HTMX for applications that are mostly forms, tables and calendars. Tangram, my planning tool for universities, works this way: the server renders HTML, HTMX swaps the parts of the page that change, and there is no separate frontend to build, deploy and keep in sync with the API.
The question I ask is simple: does this page need to behave like an app on the client? If yes, Next.js. If it's a back office, HTMX keeps it one codebase.
Data: PostgreSQL, Redis and object storage
- PostgreSQL for everything that matters. One database server, one database per product. Scoreboards started on SQLite and moved to Postgres once it had real traffic, and Django's migrations made that move a lot less scary than it sounds.
- Redis as the message broker for Celery and as the channel layer for websockets.
- Object storage for files: Cloudflare R2 for Scoreboards logos and photos, through django-storages, so the application servers stay stateless.
Mobile: Flutter, when it's needed
Most of my products are web apps that work well on a phone. When a real app is needed, I use Flutter. For Scoreboards, the people who collect match data at the stadium use a Flutter app to enter goals, cards and substitutions live from the stands.
Infrastructure: one server, Docker Swarm and Traefik
This is the part people are most surprised by. My products don't run on Kubernetes or on a big cloud bill. They run on one VPS at Contabo in Germany:
- Docker for every service, so development and production run the same images.
- Docker Swarm to run the stacks. It's built into Docker, needs no extra cluster to manage, and handles rolling updates and restarts.
- Traefik in front of everything: routing by domain and automatic HTTPS certificates. A new product is a new stack with a few labels.
- Portainer to see what's running, Grafana for dashboards, and Adminer for the rare look into the database.
- Cloudflare in front of Scoreboards, the site with the most traffic, for DNS and caching.
Everything is described in one deployment repository with a README per service. The goal is that a fresh server can be rebuilt from scratch in an afternoon: open the firewall, install Docker, clone the repo, start the stacks, restore the backups. For my newer products I write that setup as Ansible playbooks instead of shell steps.
When a product outgrows one server, I'll move it. Until then, a single well-understood machine is cheaper, faster to debug and easier to sleep next to.
Quality: tests, CI and error tracking
- Django's test runner or pytest for the backend, with tests running on PostgreSQL in CI.
- Playwright for end-to-end tests of the flows that must never break: sign up, log in, pay.
- GitHub Actions for CI on every pull request, and Dependabot to keep dependencies up to date.
- Sentry to know about errors before users write to me.
At work: Azure
My day job is a different world, and I like that it is. As an IT consultant I work mostly on Microsoft Azure: Azure Functions, Azure OpenAI and AI Document Intelligence, Azure DevOps, and the Power Platform for automation. I'm four times Azure certified, including AI Engineer Associate and Azure Administrator.
That experience shapes my own products too. I know what managed cloud services do well, which makes it easier to know when I don't need them yet.
What I deliberately leave out
- Kubernetes. Powerful, but it's a job of its own. Docker Swarm does what I need with a fraction of the moving parts.
- Microservices. The first plan for Scoreboards was microservices talking over Kafka. I built one Django project with one app per domain instead, and never regretted it.
- A new framework per project. Trying new tools is fun, so I do it in side experiments, not in products people pay for.
- Serverless for whole products. Great for small functions at work, but for my products a long-running server is simpler to reason about and cheaper at my scale.
Need a hand with yours?
This is also the stack I bring to client projects. If you are starting a web product, or your current setup has become hard to work with, I can help with:
- Choosing the stack: what fits your product and your team, and what you can skip for now.
- Building the backend: Python and Django or FastAPI, the data model, the API, authentication, background jobs.
- Deployment: Docker, CI and a setup you understand, on Azure or on your own servers.
- Reviewing what you have: slow pages, a fragile deployment, or code nobody wants to touch anymore.
Tell me about your project in a few lines. I read every message myself and reply with an honest opinion, even if the answer is that you don't need me.