A lot of people raise an eyebrow at "I write Rust backends." It's not the obvious choice — Node.js exists, Python exists, Go exists. There are easier options. But after using Rust for backend work, I can't imagine going back.
The compiler is the best code reviewer I've ever had
Rust's compiler is famously strict. It will refuse to compile code that has entire categories of bugs — memory safety issues, data races, null pointer dereferences, use-after-free. At first this feels hostile. After a while you realise it's just catching things before they become 3am production incidents.
Axum specifically
For web backends I use Axum — a Rust web framework built on Tokio, Rust's async runtime. It's fast, ergonomic, and the type system means your route handlers are checked at compile time. If a handler expects a JSON body of a certain shape and you don't handle the case where it isn't, it won't compile. That's a whole category of runtime errors that just don't exist.
The the panel backend is built on Axum with PostgreSQL via SQLx and Redis for caching and session management. The combination is genuinely excellent — fast, safe, and the async story is solid.
Performance
Rust is genuinely fast. Not "fast for a high level language" fast — fast full stop. For a hosting panel handling a lot of concurrent connections and talking to Docker APIs across multiple nodes, performance actually matters. Rust gives you C-level performance without having to write C, which is a trade I'll take every time.
It makes you think differently
Learning Rust properly changes how you think about code. Ownership, borrowing, lifetimes — these concepts don't exist in most languages, and wrestling with them forces you to think about memory and data flow in a much more explicit way. Even when I write other languages now, I write them better because of what Rust taught me.
The honest downsides
The learning curve is real. The borrow checker will make you feel stupid before it makes you feel smart. Compile times are longer than most languages. Some things that are trivial in Python take more ceremony in Rust. For quick scripts and throwaway tools, it's probably overkill.
But for a production backend that needs to be fast, correct, and maintainable? It's the best tool I've found. The upfront cost pays back every time the compiler catches something that would've been a bug in production otherwise.