Writing
Notes on running your own infrastructure.
What we learned building Anyport, and the parts of Kubernetes we think you should not have to learn. RSS
Deploying from CI with a credential that is not a person
The quickest way to deploy from CI is to paste somebody's own login into a repository secret. It works on the first day and goes wrong in four ways later. What a CI credential should be, and why the deploy step should wait for the rollout rather than the upload.
Most pull requests do not need a preview
A preview for every pull request is the default everybody ships, and most of those previews are never opened. Creating them on request turns out to be mostly a question of what the pull request comment should offer, and who is allowed to tick it.
A worker is not a web app that nobody calls
Give every app a port, a readiness check and a URL, and a queue consumer gets three things it cannot use and one it cannot pass. Why serving traffic is one decision rather than three settings, and the start command bug that tends to arrive with it.
A preview environment for the clients that cannot change their URL
A preview URL per pull request works for anyone with a browser. A mobile build, a frontend deployed elsewhere and a test suite all have the API address baked in. Routing by header on the real hostname fixes that, and the design is mostly about what happens when the header is wrong.
Why the migration ran before the database was up
Deploy one app at a time and start order never comes up. Start a whole project at once, a duplicate, a preview, a restore, and the app reaches the cluster in the same second as the database it reads from. Where start order belongs on Kubernetes, and why it should not be something you declare.
A public port, and why the platform should not pick the load balancer
Opening a raw TCP or UDP port on Kubernetes is one line of YAML. Whether that line is free, costs $15 a month, or hangs in Pending forever depends on the cluster it lands on. What a deploy platform has to know before it writes it.
Which events deserve a message, and which deserve two
A deploy platform can see everything: every rollout, every restart, every probe that failed. Sending all of it is how a channel gets muted in a week. The four decisions that separate a notification from noise, and the one case where two messages about one failure is correct.
A cron job is a second copy of your app, and that is the bug
Most scheduled jobs are an existing service with a different command. Defining them separately is how the nightly report ends up running last month's image with a rotated-out password. What a task should inherit, what it should decide for itself, and why a migration is not a task at all.
Config as code for a project: what the file should not own
Putting a project in a YAML file is the easy half. The decisions that matter are what the file must never contain: secret values, the cluster, and the permission to delete. Why each of those is a rule rather than a default.
The hard part of a preview environment is the database
Running a branch on its own URL is the easy half. What the branch talks to is the half that decides whether previews are useful, expensive, or an incident. The four answers and what each one costs.
Buildpack or Dockerfile: which should build your app
One gives you a maintained base image you never think about. The other gives you exact control. Where each one earns its place, and the case where only one works.
What a deploy platform should charge for
Every pricing model in this category follows from one fact: who owns the machines. A look at the three answers, the test a meter has to pass, and what happens on each when you stop paying.
Self-hosted PaaS: the four things you are taking on
Running the platform yourself trades a bill for a set of responsibilities. Naming them is the difference between a good decision and a surprise.
Secrets management before you buy a vault
Dedicated secret stores solve real problems, and most small teams have a different problem first. The order the work should happen in.
Kubernetes without the YAML: which parts are safe to hide
Every abstraction over Kubernetes decides what to conceal. Hide the wrong thing and the first incident is unsolvable. A test for telling them apart.
What an internal developer platform is, and when not to build one
Every company past a certain size ends up building one by accident. What the term actually covers, and the honest test for whether yours should exist.
Why every deploy should produce an immutable image tag
Deploying :latest works until the day two machines disagree about what latest is. What a content-addressed tag buys you, and what it costs.
Encryption at rest is a storage guarantee, not a privacy one
What “we encrypt your secrets” actually protects you from, what it does not, and why the distinction is worth insisting on when you evaluate anyone.
Coolify, Pangolin, and the parts you end up assembling
Two excellent tools solve two halves of this problem. Putting them together leaves you owning the seam, and the seam is where the work is.
Coming back from the cloud: what teams get wrong on the way
The hardware maths usually works. The part that surprises people is that the developer experience was the product they were buying, and it does not come back with the servers.
Multi-cluster deployment, without inheriting multi-cluster complexity
Teams end up with several clusters for good reasons and then discover the tooling assumed one. What actually gets harder, and what does not have to.
What “roll back” should mean
Re-running a pipeline against an older commit is not a rollback. The difference is a rebuild you cannot afford and a configuration change no revert covers.
A cluster with no public IP, and what still works
We took a two-node cluster with nothing but RFC1918 addresses and published a site on it over HTTPS. Here is each step, what it required, and the parts that are genuinely a trade.
Bring your own cloud, and the assumption underneath it
BYOC promises a managed experience on infrastructure you own. Most implementations quietly require your infrastructure to be reachable from theirs, which rules out a lot of real infrastructure.
Why your database sits in Pending, and what a StorageClass is
A stateful workload that never starts is usually waiting for a disk nothing has offered. What is actually happening, and the one command to run before you add a database.
Introducing Anyport: push to deploy on clusters you already own
A deploy platform for the Kubernetes clusters you already run: builds, rollbacks, domains and HTTPS from one console, with compute on your own clusters never metered.
How pausing idle projects reduces cloud spend
Shared environments create queues; per-developer environments run all night. Isolated projects you can pause when you're done are the middle path.
Serve public traffic from a private server, without opening a port
Keep every inbound port closed and still run a real site on a real domain. How an outbound-only agent and a managed gateway make that work.
From a GitHub repo to a running app
What the path from code to a live URL looks like when there's no pipeline to wire up and no YAML to write.
