Rust Axum vs Go Fiber 2026: API Sederhana untuk Klien Indonesia

Klien saya project terbaru — sistem booking salon yang mau commit ke “fast and reliable” backend — nanya: Rust atau Go? Saya freelance, jadi mereka tahu mereka akan stuck dengan tools saya. Saya kasih perbandingan honest dari pengalaman.

TL;DR

Pilih Go Fiber kalau:

• Tim Anda lebih kecil dari 5 orang
• Anda butuh deploy weekly atau lebih sering
• Junior dev bisa onboard dalam 2 minggu
• Performance “good enough” cukup

Pilih Rust Axum kalau:

• Anda punya 1 senior Rust engineer dedicated
• Latency 5ms vs 25ms matters (high-frequency trading, real-time bidding)
• Code akan run unchanged selama 5+ tahun
• Reliability > everything

Untuk SMB Indonesia biasa: Go Fiber. Saya jelaskan di bawah.

Setup untuk perbandingan

API: REST endpoint untuk booking salon. POST /bookings create booking, GET /bookings/:id retrieve, DELETE cancel. Storage: Postgres dengan single table. Auth: JWT validation. Logging: structured JSON ke stdout.

Saya tulis 2 versi: Axum dan Fiber. Same business logic.

LOC (Lines of Code)

Implementation	LOC
Axum	487
Fiber	312

Axum 56% lebih banyak code. Sebagian karena type safety verbose (every error must be explicit), sebagian karena async setup ceremonial.

Build time (cold cache)

Axum dengan minimal deps:

cargo build --release: 3 menit 42 detik

Fiber dengan minimal deps:

go build: 4 detik

Untuk dev loop fast iteration: Go decisive winner. Saya pernah lupa pakai release mode di Rust, dev build 8 menit. Suami istri klien sudah di kantor, saya masih nunggu Rust compile.

Build time (cached, incremental)

Axum incremental rebuild after 1 line change:

cargo build --release: 18 detik

Fiber incremental rebuild:

go build: 1 detik

Tetap Go 18x lebih cepat dalam dev loop.

Runtime performance

Local benchmark dengan wrk, 200 connections sustained, simple JSON response:

Metric	Axum	Fiber
Throughput req/sec	89,500	81,200
Latency p50	1.8ms	2.1ms
Latency p99	8.4ms	11.2ms
Memory	12 MB	38 MB

Rust lebih cepat ~10% di throughput, lebih efisien memory 3x. Tapi untuk API dengan 1000 req/sec (typical SMB): both well-under capacity.

Untuk klien salon (~50 booking/hari): performance tidak mattering.

Error handling experience

Axum:

async fn create_booking(
    Json(payload): Json<BookingRequest>,
    State(state): State<AppState>,
) -> Result<Json<BookingResponse>, AppError> {
    let user = validate_token(&payload.token)
        .map_err(AppError::Unauthorized)?;
    
    let booking = sqlx::query_as!(
        Booking,
        "INSERT INTO bookings (...) RETURNING *",
        // ...
    )
    .fetch_one(&state.db)
    .await
    .map_err(AppError::Database)?;
    
    Ok(Json(BookingResponse::from(booking)))
}

Type system kasih tau saya kalau ada error path yang miss. Compile time guaranteed handling.

Fiber:

func CreateBooking(c *fiber.Ctx) error {
    var req BookingRequest
    if err := c.BodyParser(&req); err != nil {
        return c.Status(400).JSON(fiber.Map{"error": "invalid body"})
    }
    
    user, err := validateToken(req.Token)
    if err != nil {
        return c.Status(401).JSON(fiber.Map{"error": "unauthorized"})
    }
    
    var booking Booking
    err = db.QueryRow(`INSERT INTO bookings (...) RETURNING *`).Scan(&booking)
    if err != nil {
        return c.Status(500).JSON(fiber.Map{"error": "database"})
    }
    
    return c.JSON(BookingResponse{...})
}

Manual error checking. Lebih verbose tapi lebih obvious untuk junior dev baca.

Junior dev onboarding

Junior dev Go (no prior Go): produktif dalam 1-2 minggu. Syntax intuitif, error message clear, ecosystem mature.

Junior dev Rust (no prior Rust): produktif dalam 6-12 minggu. Borrow checker fight, lifetime annotation, async ceremonies. Steeper learning curve.

Untuk freelance project klien yang mungkin akan dilanjutkan oleh dev lain: Go lebih kind.

Library ecosystem

Untuk fitur “saya butuh redis client” / “saya butuh AWS S3 client”:

Go: official + 3rd party libraries, mostly battle-tested at major companies. Easy choice.

Rust: ada library, tapi banyak yang masih < v1.0, breaking changes occasional. Anda perlu spend waktu evaluate.

Deployment

Go: single binary, ~20MB. Drop ke server, jalankan via systemd. Done.

Rust: single binary, ~30MB (lebih besar karena Rust dependencies). Same deploy story.

Both excellent untuk deploy.

Yang saya pilih untuk klien salon

Go Fiber. Reasoning:

1. Junior dev klien akan butuh maintain code setelah project saya selesai. Go lebih kind.
2. Performance Fiber lebih dari cukup (50 booking/hari is 0.0006 req/sec, both bisa).
3. Build time fast = iteration fast = pelaksanaan project lebih cepat.
4. Library ecosystem Go untuk fitur klien (Midtrans payment gateway, Whatsapp notification API, dll) lebih lengkap.

Untuk klien yang punya senior Rust engineer dedicated, atau klien fintech yang butuh formal verification: Rust make sense. Untuk SMB biasa: Go.

Saran untuk dev Indonesia

Belajar Rust kalau Anda penasaran dan punya 2-3 bulan untuk invest. Yang Anda dapat: better understanding of memory, ownership, async, type systems. Itu akan benefit semua language.

Tapi untuk produce work for clients sekarang: Go is the responsible choice. Lebih murah waktu produksi, lebih kind ke dev lain, performance overlap.