Videos

Spring Boot took 2.26 seconds to wake up. Quarkus did it in 83 milliseconds. Same API. Same Podman lane. Same load driver. Quarkus also held the stronger runtime lane here on throughput, RSS, and p99 latency. The full breakdown goes deeper into the build lane, fairness rules, and where Spring Boot

I built the same Java API twice: once in Spring Boot and once in Quarkus. Same contract. Same JSON shape. Same Podman runtime. Same `wrk` load driver. This is not a fake benchmark where one side quietly gets an easier problem. The point was to see what actually changes when the exact same backend

If prod gets rebuilt, prod was never tested below it. This short shows why branch-per-environment creates artifact drift, why commit SHA is not enough, and why trustworthy CI/CD means one commit, one artifact, one digest. Full breakdown on the channel. #devops #cicd #softwareengineering #platformen

Fast APIs can still lose in production. In this short, the benchmark verdict flips once we stop trusting accepted traffic and start measuring completed work, Kafka lag, and tail latency. Spring drained the queue. Go and .NET accepted traffic, but left debt behind under pressure. Watch the full lo

Spring Boot won this benchmark, but not for the lazy reason. This was not a branding contest and it was not just another throughput scoreboard. I built a full benchmark engine, ran the same Kafka plus Postgres order pipeline across Go, Spring Boot, and .NET, and then checked the only metric that ac

Most teams say they have CI/CD because code moves from `dev` to `staging` to `prod`. But if every environment rebuilds the app, the thing you tested below is not the thing running in production. That is not promotion. That is drift with better branding. In this video: - why source promotion and a

If your `docker-compose.yml` is not in Git, you do not have infrastructure. You have a live guessing game. This short shows the blunt ops version: - Compose edits are production config - Git is the control plane for diffs, review, and rollback - Live-editing YAML on a server is how outages turn in

Same tool logic. Same host machine. Two boundaries. In this short, I compare an in-process tool path against the same tool running behind a remote MCP-style server boundary. The result was not close: local p95 landed at 0.018 ms, remote p95 landed at 12.716 ms, and the remote lane started dropping

The fastest backend on the chart still lost the production verdict. This short shows why raw throughput is not enough to pick a backend stack. In this video: - C# wins raw speed - Go wins the actual payoff score - Rust stays the efficiency specialist - memory and startup change the final decision

One chart is not enough for a production stack decision. Which Backend Actually Pays For Itself In 2026? In this video: - what each runtime/language wins - where tail latency changes the decision - how to pick based on your real bottleneck Comment with your stack and workload; I can publish the b

Rust winning this benchmark was not the weird part. The weird part was PHP taking second over Elixir under the same live load. Same /work endpoint. Same JSON payload. Same Podman host. Same concurrency ramp. Same sampling cadence. At c300, Rust stayed in a different class on throughput and memory.

Same `/work` endpoint. Same JSON payload. Same Podman box. Same live ramp from 10 to 300 concurrent users. Result: - Rust wins throughput, latency, and memory - PHP takes second place - Elixir pays the biggest memory tax in this run In this video: - live RSS ramp - throughput across c10, c50, c150