How to Switch from Java 24 to Rust 1.85 Backend Development in 2026 – Roadmap with 500k Engineer Survey Data

// src/main.rs
// Required dependencies in Cargo.toml:
// [dependencies]
// axum = \"0.7\"
// tokio = { version = \"1.38\", features = [\"full\"] }
// sqlx = { version = \"0.7\", features = [\"postgres\", \"runtime-tokio-native-tls\", \"macros\"] }
// redis = { version = \"0.25\", features = [\"tokio-comp\"] }
// serde = { version = \"1.0\", features = [\"derive\"] }
// serde_json = \"1.0\"
// tracing = \"0.1\"
// tracing-subscriber = { version = \"0.3\", features = [\"env-filter\"] }
// metrics = \"0.21\"
// metrics-exporter-prometheus = \"0.12\"
// validator = { version = \"0.18\", features = [\"derive\"] }
// uuid = { version = \"1.8\", features = [\"v4\", \"serde\"] }
// chrono = { version = \"0.4\", features = [\"serde\"] }

use axum::{
    extract::{Json, State},
    http::StatusCode,
    routing::{get, post},
    Router,
};
use sqlx::postgres::PgPoolOptions;
use redis::aio::MultiplexedConnection;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use metrics_exporter_prometheus::PrometheusBuilder;
use std::net::SocketAddr;
use std::time::Duration;

// Custom error type for the application
#[derive(Debug)]
enum AppError {
    Database(sqlx::Error),
    Redis(redis::RedisError),
    Validation(String),
    NotFound,
}

// Implement Display for AppError to satisfy error requirements
impl std::fmt::Display for AppError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AppError::Database(e) => write!(f, \"Database error: {}\", e),
            AppError::Redis(e) => write!(f, \"Redis error: {}\", e),
            AppError::Validation(e) => write!(f, \"Validation error: {}\", e),
            AppError::NotFound => write!(f, \"Resource not found\"),
        }
    }
}

// Implement Error trait for AppError
impl std::error::Error for AppError {}

// Convert sqlx errors to AppError automatically
impl From for AppError {
    fn from(err: sqlx::Error) -> Self {
        AppError::Database(err)
    }
}

// Convert redis errors to AppError automatically
impl From for AppError {
    fn from(err: redis::RedisError) -> Self {
        AppError::Redis(err)
    }
}

// Axum requires IntoResponse for error types
impl axum::response::IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let (status, message) = match self {
            AppError::Database(_) => (StatusCode::INTERNAL_SERVER_ERROR, \"Internal database error\"),
            AppError::Redis(_) => (StatusCode::INTERNAL_SERVER_ERROR, \"Internal cache error\"),
            AppError::Validation(e) => (StatusCode::BAD_REQUEST, Box::leak(e.into_boxed_str())),
            AppError::NotFound => (StatusCode::NOT_FOUND, \"Resource not found\"),
        };
        (status, message).into_response()
    }
}

// Shared application state passed to all handlers
#[derive(Clone)]
struct AppState {
    db_pool: sqlx::PgPool,
    redis_conn: MultiplexedConnection,
}

// Health check handler - no state required
async fn health_check() -> &'static str {
    \"OK\"
}

// Order creation request payload with validation
#[derive(serde::Deserialize, validator::Validate)]
struct CreateOrderRequest {
    #[validate(length(min = 1, max = 255))]
    user_id: String,
    #[validate(length(min = 1))]
    product_id: String,
    quantity: i32,
}

// Order response payload
#[derive(serde::Serialize)]
struct OrderResponse {
    id: uuid::Uuid,
    user_id: String,
    product_id: String,
    quantity: i32,
    created_at: chrono::DateTime,
}

// Order creation handler with state extraction
async fn create_order(
    State(state): State,
    Json(payload): Json,
) -> Result, AppError> {
    // Validate request payload
    payload.validate().map_err(|e| AppError::Validation(e.to_string()))?;

    // Start metrics timer for order creation
    let timer = metrics::histogram!(\"order_creation_duration_seconds\").start_timer();

    // Insert order into Postgres
    let order_id = uuid::Uuid::new_v4();
    let created_at = chrono::Utc::now();
    sqlx::query!(
        r#\"
        INSERT INTO orders (id, user_id, product_id, quantity, created_at)
        VALUES ($1, $2, $3, $4, $5)
        \"#,
        order_id,
        payload.user_id,
        payload.product_id,
        payload.quantity,
        created_at
    )
    .execute(&state.db_pool)
    .await?;

    // Cache order in Redis for 5 minutes
    let cache_key = format!(\"order:{}\", order_id);
    let order_response = OrderResponse {
        id: order_id,
        user_id: payload.user_id,
        product_id: payload.product_id,
        quantity: payload.quantity,
        created_at,
    };
    let cache_value = serde_json::to_string(&order_response)?;
    redis::cmd(\"SETEX\")
        .arg(&cache_key)
        .arg(300) // 5 minutes TTL
        .arg(&cache_value)
        .query_async(&mut state.redis_conn.clone())
        .await?;

    // Stop metrics timer
    timer.stop_and_record();

    // Increment order creation counter
    metrics::counter!(\"order_creations_total\").increment(1);

    Ok(Json(order_response))
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Initialize tracing for structured logging
    tracing_subscriber::registry()
        .with(tracing_subscriber::EnvFilter::new(
            std::env::var(\"RUST_LOG\").unwrap_or_else(|_| \"info\".into()),
        ))
        .with(tracing_subscriber::fmt::layer())
        .init();

    // Initialize Prometheus metrics exporter
    PrometheusBuilder::new()
        .listen(\"0.0.0.0:9090\".parse()?)
        .install()?;

    // Connect to Postgres with connection pooling
    let db_pool = PgPoolOptions::new()
        .max_connections(20)
        .acquire_timeout(Duration::from_secs(5))
        .connect(&std::env::var(\"DATABASE_URL\")?)
        .await?;

    // Run database migrations on startup
    sqlx::migrate!(\"./migrations\")
        .run(&db_pool)
        .await?;

    // Connect to Redis
    let redis_client = redis::Client::open(std::env::var(\"REDIS_URL\")?)?;
    let redis_conn = redis_client.get_multiplexed_tokio_connection().await?;

    // Create shared application state
    let state = AppState { db_pool, redis_conn };

    // Build Axum router with routes
    let app = Router::new()
        .route(\"/health\", get(health_check))
        .route(\"/orders\", post(create_order))
        .with_state(state);

    // Start HTTP server
    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
    tracing::info!(\"Listening on {}\", addr);
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await?;

    Ok(())
}

// migrations/20260101000000_create_orders.sql
CREATE TABLE IF NOT EXISTS orders (
    id UUID PRIMARY KEY,
    user_id VARCHAR(255) NOT NULL,
    product_id VARCHAR(255) NOT NULL,
    quantity INTEGER NOT NULL CHECK (quantity > 0),
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

CREATE INDEX IF NOT EXISTS idx_orders_user_id ON orders(user_id);
CREATE INDEX IF NOT EXISTS idx_orders_created_at ON orders(created_at DESC);

// src/repositories/order.rs
use sqlx::{PgPool, query_as, query};
use uuid::Uuid;
use chrono::{DateTime, Utc};
use crate::AppError;

// Order struct matching database schema
#[derive(sqlx::FromRow, serde::Serialize)]
pub struct Order {
    pub id: Uuid,
    pub user_id: String,
    pub product_id: String,
    pub quantity: i32,
    pub created_at: DateTime,
}

// Order repository with database pool
pub struct OrderRepository {
    db_pool: PgPool,
}

impl OrderRepository {
    pub fn new(db_pool: PgPool) -> Self {
        Self { db_pool }
    }

    // Create a new order in the database
    pub async fn create_order(
        &self,
        user_id: &str,
        product_id: &str,
        quantity: i32,
    ) -> Result {
        let order_id = Uuid::new_v4();
        let created_at = Utc::now();

        let order = query_as!(
            Order,
            r#\"
            INSERT INTO orders (id, user_id, product_id, quantity, created_at)
            VALUES ($1, $2, $3, $4, $5)
            RETURNING id, user_id, product_id, quantity, created_at
            \"#,
            order_id,
            user_id,
            product_id,
            quantity,
            created_at
        )
        .fetch_one(&self.db_pool)
        .await?;

        Ok(order)
    }

    // Get order by ID with caching hint
    pub async fn get_order_by_id(
        &self,
        order_id: Uuid,
    ) -> Result, AppError> {
        let order = query_as!(
            Order,
            r#\"
            SELECT id, user_id, product_id, quantity, created_at
            FROM orders
            WHERE id = $1
            \"#,
            order_id
        )
        .fetch_optional(&self.db_pool)
        .await?;

        Ok(order)
    }

    // Get all orders for a user with pagination
    pub async fn get_orders_by_user(
        &self,
        user_id: &str,
        limit: i64,
        offset: i64,
    ) -> Result, AppError> {
        let orders = query_as!(
            Order,
            r#\"
            SELECT id, user_id, product_id, quantity, created_at
            FROM orders
            WHERE user_id = $1
            ORDER BY created_at DESC
            LIMIT $2 OFFSET $3
            \"#,
            user_id,
            limit,
            offset
        )
        .fetch_all(&self.db_pool)
        .await?;

        Ok(orders)
    }

    // Update order quantity (simplified for example)
    pub async fn update_order_quantity(
        &self,
        order_id: Uuid,
        new_quantity: i32,
    ) -> Result, AppError> {
        if new_quantity <= 0 {
            return Err(AppError::Validation(\"Quantity must be positive\".into()));
        }

        let order = query_as!(
            Order,
            r#\"
            UPDATE orders
            SET quantity = $1
            WHERE id = $2
            RETURNING id, user_id, product_id, quantity, created_at
            \"#,
            new_quantity,
            order_id
        )
        .fetch_optional(&self.db_pool)
        .await?;

        Ok(order)
    }

    // Delete order by ID
    pub async fn delete_order(
        &self,
        order_id: Uuid,
    ) -> Result {
        let result = query!(
            r#\"
            DELETE FROM orders
            WHERE id = $1
            \"#,
            order_id
        )
        .execute(&self.db_pool)
        .await?;

        Ok(result.rows_affected() > 0)
    }
}

// Unit tests for order repository (requires test database)
#[cfg(test)]
mod tests {
    use super::*;
    use sqlx::postgres::PgPoolOptions;

    #[tokio::test]
    async fn test_create_and_get_order() -> Result<(), AppError> {
        // Connect to test database (set TEST_DATABASE_URL env var)
        let db_pool = PgPoolOptions::new()
            .max_connections(5)
            .connect(&std::env::var(\"TEST_DATABASE_URL\").unwrap())
            .await?;

        // Run migrations for test database
        sqlx::migrate!(\"./migrations\")
            .run(&db_pool)
            .await?;

        let repo = OrderRepository::new(db_pool);
        let user_id = \"test_user_123\";
        let product_id = \"test_product_456\";
        let quantity = 2;

        // Create order
        let order = repo.create_order(user_id, product_id, quantity).await?;

        // Verify order fields
        assert_eq!(order.user_id, user_id);
        assert_eq!(order.product_id, product_id);
        assert_eq!(order.quantity, quantity);

        // Get order by ID
        let fetched_order = repo.get_order_by_id(order.id).await?;
        assert!(fetched_order.is_some());
        let fetched_order = fetched_order.unwrap();
        assert_eq!(fetched_order.id, order.id);

        Ok(())
    }
}

// src/tests/integration.rs
use testcontainers::{clients::Cli, images::postgres::Postgres, images::redis::Redis, Container};
use sqlx::postgres::PgPoolOptions;
use redis::Client as RedisClient;
use axum::body::Body;
use axum::http::{Request, StatusCode};
use tower::ServiceExt; // for `call` method
use serde_json::json;
use crate::AppState;
use crate::repositories::OrderRepository;

// Helper to set up test containers and app state
async fn setup_test_app() -> (Container, Container, AppState) {
    let docker = Cli::default();

    // Start Postgres test container
    let postgres_image = Postgres::default()
        .with_db_name(\"test_db\")
        .with_user(\"test_user\")
        .with_password(\"test_password\");
    let postgres_container = docker.run(postgres_image);
    let postgres_port = postgres_container.get_host_port_ipv4(5432);
    let database_url = format!(
        \"postgresql://test_user:test_password@localhost:{}/test_db\",
        postgres_port
    );

    // Start Redis test container
    let redis_image = Redis::default();
    let redis_container = docker.run(redis_image);
    let redis_port = redis_container.get_host_port_ipv4(6379);
    let redis_url = format!(\"redis://localhost:{}\", redis_port);

    // Connect to Postgres and run migrations
    let db_pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .expect(\"Failed to connect to test Postgres\");
    sqlx::migrate!(\"./migrations\")
        .run(&db_pool)
        .await
        .expect(\"Failed to run migrations\");

    // Connect to Redis
    let redis_client = RedisClient::open(redis_url).expect(\"Failed to create Redis client\");
    let redis_conn = redis_client
        .get_multiplexed_tokio_connection()
        .await
        .expect(\"Failed to connect to test Redis\");

    let state = AppState { db_pool, redis_conn };

    (postgres_container, redis_container, state)
}

// Test health check endpoint
#[tokio::test]
async fn test_health_check() {
    let (_pg, _redis, state) = setup_test_app().await;

    let app = axum::Router::new()
        .route(\"/health\", axum::routing::get(crate::health_check))
        .with_state(state);

    let response = app
        .oneshot(
            Request::builder()
                .uri(\"/health\")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::OK);
    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
    assert_eq!(&body[..], b\"OK\");
}

// Test order creation endpoint
#[tokio::test]
async fn test_create_order() {
    let (_pg, _redis, state) = setup_test_app().await;

    let app = axum::Router::new()
        .route(\"/orders\", axum::routing::post(crate::create_order))
        .with_state(state);

    let payload = json!({
        \"user_id\": \"test_user_123\",
        \"product_id\": \"test_product_456\",
        \"quantity\": 2
    });

    let response = app
        .oneshot(
            Request::builder()
                .uri(\"/orders\")
                .method(\"POST\")
                .header(\"content-type\", \"application/json\")
                .body(Body::from(payload.to_string()))
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::OK);
    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
    let order: serde_json::Value = serde_json::from_slice(&body).unwrap();
    assert_eq!(order[\"user_id\"], \"test_user_123\");
    assert_eq!(order[\"product_id\"], \"test_product_456\");
    assert_eq!(order[\"quantity\"], 2);
}

// Test order creation with invalid payload (missing quantity)
#[tokio::test]
async fn test_create_order_invalid_payload() {
    let (_pg, _redis, state) = setup_test_app().await;

    let app = axum::Router::new()
        .route(\"/orders\", axum::routing::post(crate::create_order))
        .with_state(state);

    let payload = json!({
        \"user_id\": \"test_user_123\",
        \"product_id\": \"test_product_456\"
        // Missing quantity
    });

    let response = app
        .oneshot(
            Request::builder()
                .uri(\"/orders\")
                .method(\"POST\")
                .header(\"content-type\", \"application/json\")
                .body(Body::from(payload.to_string()))
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}

// Test order creation with invalid quantity (zero)
#[tokio::test]
async fn test_create_order_invalid_quantity() {
    let (_pg, _redis, state) = setup_test_app().await;

    let app = axum::Router::new()
        .route(\"/orders\", axum::routing::post(crate::create_order))
        .with_state(state);

    let payload = json!({
        \"user_id\": \"test_user_123\",
        \"product_id\": \"test_product_456\",
        \"quantity\": 0 // Invalid: must be positive
    });

    let response = app
        .oneshot(
            Request::builder()
                .uri(\"/orders\")
                .method(\"POST\")
                .header(\"content-type\", \"application/json\")
                .body(Body::from(payload.to_string()))
                .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
}

// Rust: Ownership transfer example
fn process_order(order_id: String) -> String {
    // order_id is owned by this function; caller no longer has access
    format!(\"Processing order: {}\", order_id)
}

// Java equivalent: no ownership transfer, reference passed
// public String processOrder(String orderId) {
//     return \"Processing order: \" + orderId;
// }

// Axum: Extract JSON body with validation
async fn create_order(Json(payload): Json) -> Result, AppError> {
    payload.validate()?; // Validate using validator crate
    // ...
}

// Java Spring: Extract JSON body
// @PostMapping(\"/orders\")
// public Order createOrder(@Valid @RequestBody CreateOrderRequest payload) {
//     // ...
// }

// benches/order_bench.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use uuid::Uuid;

fn order_creation_benchmark(c: &mut Criterion) {
    let mut order_repo = // Initialize test order repository
    c.bench_function(\"order_creation\", |b| {
        b.iter(|| {
            // Black box prevents compiler from optimizing away the call
            black_box(order_repo.create_order(\"user_123\", \"product_456\", 2))
        })
    });
}

criterion_group!(benches, order_creation_benchmark);
criterion_main!(benches);

rust-order-service/
├── Cargo.toml                  # Project dependencies and metadata
├── migrations/                 # SQLx database migrations
│   ├── 20260101000000_create_orders.sql
│   └── 20260101000001_add_order_indexes.sql
├── src/
│   ├── main.rs                 # Application entry point (code example 1)
│   ├── errors.rs               # Custom AppError type
│   ├── handlers/
│   │   └── order.rs            # Order HTTP handlers
│   ├── repositories/
│   │   └── order.rs            # Order database repository (code example 2)
│   └── tests/
│       └── integration.rs      # Integration tests (code example 3)
├── benches/
│   └── order_bench.rs          # Criterion benchmarks
├── .github/
│   └── workflows/
│       └── ci.yml              # GitHub Actions CI pipeline
└── README.md                   # Project documentation