Building Production Apps with Rust and Axum

After years of Node.js and Python, I made the switch to Rust for backend development. The learning curve was steep, but the payoff in performance and reliability has been remarkable.

Why Rust?

I came to Rust after building dozens of production systems in Node.js and Python. Both are great languages, but they have limitations:

• Node.js ? Single-threaded, runtime errors, callback complexity
• Python ? Slow for CPU-intensive work, GIL limitations, type confusion

Rust offered something different: performance comparable to C++, memory safety without garbage collection, and a type system that catches errors at compile time rather than runtime.

The Learning Curve

Let's be honest: Rust is hard to learn. The borrow checker will humble you. Lifetimes will confuse you. The first few weeks are frustrating.

But here's the thing ? those strict rules that make Rust hard to learn also make it hard to write buggy code. Once your code compiles, it usually works correctly. Memory leaks, null pointer exceptions, data races ? entire categories of bugs simply don't exist in safe Rust.

Why Axum?

Axum is a web framework built on top of Tokio (async runtime) and Tower (middleware). Why Axum over Actix or Rocket?

• Tokio ecosystem ? Integrates seamlessly with the most popular async runtime
• Type-safe extractors ? Request parsing that catches errors at compile time
• Middleware composition ? Tower's service layers are powerful and composable
• Maintained by Tokio team ? Strong long-term support

Project Structure

Here's how I typically structure an Axum project:

src/
+-- main.rs           # Entry point, server setup
+-- config.rs         # Configuration management
+-- routes/           # Route handlers organized by domain
?   +-- mod.rs
?   +-- auth.rs
?   +-- api.rs
+-- handlers/         # Request handlers
+-- services/         # Business logic
+-- models/           # Data structures
+-- db/               # Database operations
+-- middleware/       # Custom middleware

Database: SQLx

For database access, I use SQLx with PostgreSQL. SQLx provides:

• Compile-time query checking ? SQL syntax errors caught before runtime
• Async by default ? Non-blocking database operations
• Raw SQL ? No ORM magic, just queries you can understand
• Migrations ? Built-in schema migration support

Error Handling

Rust's Result type forces you to handle errors explicitly. Combined with the ? operator and custom error types, error handling becomes systematic rather than ad-hoc.

async fn get_user(id: i32) -> Result {
    let user = sqlx::query_as!(User, 
        "SELECT * FROM users WHERE id = $1", id
    )
    .fetch_optional(&pool)
    .await?
    .ok_or(AppError::NotFound)?;
    
    Ok(user)
}

Performance Results

After migrating several services from Node.js to Rust:

• Response times ? 3-5x faster on average
• Memory usage ? 10x less memory for equivalent workloads
• CPU usage ? Significant reduction under load
• Reliability ? Zero runtime crashes in production

When Not to Use Rust

Rust isn't the right choice for everything:

• Rapid prototyping ? Python or Node.js is faster for exploration
• Small scripts ? Overhead isn't worth it for simple tasks
• Team experience ? If your team doesn't know Rust, there's a ramp-up cost

For production services where performance and reliability matter, though, Rust has become my default choice.

Getting Started

If you're interested in Rust for web development:

1. Work through the Rust Book
2. Build a simple CLI tool to get comfortable with the language
3. Start a small Axum project ? a REST API or similar
4. Gradually increase complexity as understanding grows

The investment is worth it.