Forem: Syeed Talha

Implementing POST and GET in Axum using in-memory storage.

Syeed Talha — Tue, 14 Apr 2026 10:26:10 +0000

Step 1 — Create the project

cargo new axum-demo
cd axum-demo

Add dependencies to Cargo.toml:

[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Step 2 — The full `main.rs`

use axum::{
    extract::State,
    http::StatusCode,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::{Arc, Mutex};

// ── 1. Data model ──────────────────────────────────────────────────────────────
// In FastAPI you'd write:
//   class User(BaseModel):
//       id: int
//       name: str
//       email: str
//
// In Rust we derive Serialize (→ JSON output) and Deserialize (← JSON input)

#[derive(Debug, Serialize, Deserialize, Clone)]
struct User {
    id: u32,
    name: String,
    email: String,
}

// Only these fields are required when CREATING a user (no id yet)
// FastAPI equivalent: class CreateUser(BaseModel): name: str; email: str
#[derive(Debug, Deserialize)]
struct CreateUser {
    name: String,
    email: String,
}

// ── 2. Shared in-memory state ──────────────────────────────────────────────────
// Arc  = shared ownership across threads (like Python's threading.Lock wrapper)
// Mutex= only one thread can write at a time
// Vec  = growable list (like Python's list)
type AppState = Arc<Mutex<Vec<User>>>;

// ── 3. Handlers ───────────────────────────────────────────────────────────────

// POST /users
// FastAPI equivalent:
//   @app.post("/users", status_code=201)
//   def create_user(body: CreateUser):
//       ...
async fn create_user(
    State(state): State<AppState>,   // Axum injects shared state automatically
    Json(body): Json<CreateUser>,    // Axum parses the JSON body automatically
) -> (StatusCode, Json<User>) {
    let mut users = state.lock().unwrap(); // lock the Mutex to get write access

    let new_user = User {
        id: users.len() as u32 + 1,  // simple auto-increment
        name: body.name,
        email: body.email,
    };

    users.push(new_user.clone());

    (StatusCode::CREATED, Json(new_user)) // returns 201 + the created user as JSON
}

// GET /users
// FastAPI equivalent:
//   @app.get("/users")
//   def list_users():
//       ...
async fn list_users(
    State(state): State<AppState>,
) -> Json<Vec<User>> {
    let users = state.lock().unwrap(); // lock for read access
    Json(users.clone())                // return a copy as JSON
}

// ── 4. main — wire everything together ────────────────────────────────────────
#[tokio::main]  // like: if __name__ == "__main__": uvicorn.run(app)
async fn main() {
    let state: AppState = Arc::new(Mutex::new(vec![])); // start with empty list

    let app = Router::new()
        .route("/users", post(create_user)) // POST /users → create_user handler
        .route("/users", get(list_users))   // GET  /users → list_users handler
        .with_state(state);                 // attach shared state to all routes

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    println!("Server running on http://localhost:3000");
    axum::serve(listener, app).await.unwrap();
}

Step 3 — Run and test

cargo run

Create a user:

curl -X POST http://localhost:3000/users \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "email": "alice@example.com"}'

# Response: {"id":1,"name":"Alice","email":"alice@example.com"}

List all users:

curl http://localhost:3000/users

# Response: [{"id":1,"name":"Alice","email":"alice@example.com"}]

Key concepts to remember

🔹 `Debug`

Lets you print the struct in a developer‑friendly way using println!("{:?}", user).
Without it, you can’t easily inspect values during debugging.

🔹 `Serialize`

Comes from Serde.
Allows you to convert your struct into JSON (or other formats).
Example: turn User { id: 1, name: "Alice".to_string(), email: "a@b.com".to_string() } into:

  {
    "id": 1,
    "name": "Alice",
    "email": "a@b.com"
  }

🔹 `Deserialize`

Also from Serde.
Allows you to take JSON (or other formats) and build your struct back.
Example: given the JSON above, Serde can create a User struct automatically.

🔹 `Clone`

Lets you make a copy of the struct.
Example:

  let user1 = User { id: 1, name: "Alice".to_string(), email: "a@b.com".to_string() };
  let user2 = user1.clone(); // now user2 is a copy of user1

Without Clone, you couldn’t duplicate the struct this way.

Why all together?

Debug → for printing and debugging.
Serialize + Deserialize → for JSON in/out (essential in web APIs).
Clone → for copying values when needed.

So this combination makes your User struct easy to debug, send/receive as JSON, and duplicate safely.

Now lets understand Arc<Mutex<Vec<User>>> & State(...)

`Arc<Mutex<Vec<User>>>` — The shared notebook

Imagine you run a small shop. You have one notebook where you write down customer names.

Now imagine multiple cashiers (= multiple request handlers running at the same time). They all need to read and write that same notebook.

Two problems arise:

Problem 1 — Who owns the notebook?
In Rust, every value has exactly one owner. But you need all cashiers to share it. Arc solves this — think of it as a photocopy machine that gives everyone a pointer to the same original notebook. Nobody owns it exclusively; everyone just holds a reference.

Arc = shared ownership across threads. When the last cashier is done, it auto-deletes.

Problem 2 — Two cashiers writing at the same time = chaos
If cashier A and cashier B both write at the exact same millisecond, the notebook gets corrupted. Mutex solves this — think of it as a physical lock on the notebook cabinet. Only one cashier can open it at a time. Others wait.

Mutex = take a lock, do your work, release the lock

So the full picture:

Arc         <  Mutex      <  Vec<User>  >>
"shared"       "one at       "the actual
 pointer"       a time"       notebook"

In Python you almost never think about this because Python's GIL handles it behind the scenes. In Rust, you are explicit about it — which makes it safer.

`State(...)` — The magic backpack

When your server starts, you create the notebook (the Vec) and put it in a backpack:

let state = Arc::new(Mutex::new(vec![]));

let app = Router::new()
    .route("/users", post(create_user))
    .with_state(state);  // 👈 put it in the backpack

Now every incoming request automatically carries that backpack. When a handler wants the notebook, it just asks for it:

async fn create_user(
    State(state): State<AppState>,  // 👈 "give me what's in the backpack"
    Json(body): Json<CreateUser>,
) { ... }

Axum sees State(AppState) in the function signature and says "oh, this handler needs the shared state — let me inject it automatically."

FastAPI comparison:

# FastAPI — you use Depends() to inject shared things
def get_db():
    return fake_db

@app.post("/users")
def create_user(body: CreateUser, db=Depends(get_db)):
    #                              ^^^^^^^^^^^^^^^^
    #                              FastAPI injects this

// Axum — you use State(...) to inject shared things
async fn create_user(
    State(state): State<AppState>,  // Axum injects this
    Json(body): Json<CreateUser>,
) { ... }

Same idea — the framework injects a shared dependency into your function. The syntax is just different.

One more thing — why does Rust force you to think about this?

In Python, you write:

users = []  # global list, everyone just uses it

@app.post("/users")
def create_user(body: CreateUser):
    users.append(...)  # just works, Python handles safety behind the scenes

Python hides the complexity. Rust makes you say it out loud:

// "This is a list, shared across threads, protected by a lock"
let state: Arc<Mutex<Vec<User>>> = Arc::new(Mutex::new(vec![]));

It feels verbose at first, but this is exactly why Rust programs don't have race conditions — you cannot accidentally share data unsafely. The compiler won't let you.

So we can say, Arc<Mutex<Vec<User>>> is the "database" for now. Arc lets multiple request handlers share the same data. Mutex ensures only one handler writes at a time — without it, two simultaneous POST requests could corrupt the list.

State(...) — Axum automatically injects the shared state into any handler that asks for it. In FastAPI you'd use Depends() for something similar.

Json(...) does double duty — as an extractor in function parameters (parses incoming JSON) and as a response type in the return value (serializes to JSON output).

(StatusCode, Json<T>) as a return type is how you return both a status code and a body. Returning just Json<T> implicitly gives a 200 OK.

Thank you for reading ^_^

Beginner’s Guide to Axum: Path, Query & JSON

Syeed Talha — Tue, 14 Apr 2026 05:58:35 +0000

If you're starting backend development in Rust, Axum is a great choice.

In this guide, we will build a small API and learn:

✅ Path Parameters
✅ Query Parameters
✅ JSON Request & Response

And most importantly: you’ll get the FULL working code at the end.

What We Are Building

We will create 3 routes:

Route	Method	Description
`/user/:name/:id/:age`	GET	Path parameters
`/search?name=...&age=...`	GET	Query parameters
`/user`	POST	JSON request

Required Dependencies

We use serde for converting data.

Add this to your Cargo.toml:

[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }

1. Path Parameters

Example URL

/user/talha/10/22

👉 Here:

name = talha
id = 10
age = 22

Code

async fn get_user(Path((name, id, age)): Path<(String, i32, i32)>) -> String {
    format!("User Name is: {}\n, age: {}\n and Id is {}", name, age, id)
}

Axum extracts values directly from the URL.

2. Query Parameters

Example URL

/search?name=talha&age=22

Struct

#[derive(Deserialize)]
struct SearchParams {
    name: String,
    age: i32,
}

Code

async fn search(Query(params): Query<SearchParams>) -> String {
    format!("User name is {} and he is now {} years old", params.name, params.age)
}

Axum converts query into a struct automatically.

3. JSON Request & Response (POST)

Request JSON

{
  "name": "Talha",
  "age": 22
}

Structs

#[derive(Deserialize)]
struct CreateUser {
    name: String,
    age: i32,
}

#[derive(Serialize)]
struct UserResponse {
    message: String,
}

Code

async fn create_user(Json(payload): Json<CreateUser>) -> Json<UserResponse> {
    let msg = format!("User {} is {} years old", payload.name, payload.age);

    Json(UserResponse {
        message: msg,
    })
}

Full Working Code (Copy & Run)

This is the complete code you can copy and run directly:

use axum::{
    routing::{get, post},
    Router,
    extract::{Path, Query, Json},
};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct SearchParams {
    name: String,
    age: i32,
}

#[derive(Deserialize)]
struct CreateUser {
    name: String,
    age: i32,
}

#[derive(Serialize)]
struct UserResponse {
    message: String,
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/user/:name/:id/:age", get(get_user))
        .route("/search", get(search))
        .route("/user", post(create_user));

    let addr = "127.0.0.1:3000";
    println!("Server running on http://{}", addr);

    axum::serve(
        tokio::net::TcpListener::bind(addr).await.unwrap(),
        app,
    )
    .await
    .unwrap();
}

async fn get_user(Path((name, id, age)): Path<(String, i32, i32)>) -> String {
    format!("User Name is: {}\n, age: {}\n and Id is {}", name, age, id)
}

async fn search(Query(params): Query<SearchParams>) -> String {
    format!(
        "User name is {} and he is now {} years old",
        params.name, params.age
    )
}

async fn create_user(Json(payload): Json<CreateUser>) -> Json<UserResponse> {
    let msg = format!("User {} is {} years old", payload.name, payload.age);

    Json(UserResponse {
        message: msg,
    })
}

How to Run

cargo run

Then test in browser or Postman:

Test Path

http://localhost:3000/user/talha/10/22

Test Query

http://localhost:3000/search?name=talha&age=22

Test POST (Important)

Use Postman / curl:

curl -X POST http://localhost:3000/user \
-H "Content-Type: application/json" \
-d '{"name":"Talha","age":22}'

What You Learned

✔ Path parameters → Path<T>
✔ Query parameters → Query<T>
✔ JSON body → Json<T>
✔ Structs + Serde = powerful API

Understand Your First Axum Server by Comparing with FastAPI

Syeed Talha — Sun, 12 Apr 2026 18:42:15 +0000

If you're coming from Python and have used FastAPI, learning Rust’s Axum can feel confusing at first. But the good news is: the core ideas are almost the same.

Let’s break down this simple Axum server step by step and compare it with FastAPI so it clicks instantly.

🧩 The Full Code

use axum::{ routing::get, Router, };
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    // 1. Create a route
    let app = Router::new()
        .route("/", get(root));

    // 2. Define address
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    println!("Server running at http://{}", addr);

    // 3. Run server
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// 4. Handler function
async fn root() -> &'static str {
    "Hello, Axum! Hello guys how are you!!!"
}

🧠 Big Picture

This program does 4 simple things:

Create a web app
Define a route (/)
Start a server on 127.0.0.1:3000
Return a response when someone visits

🔹 Step 1: Importing Things

use axum::{ routing::get, Router };
use std::net::SocketAddr;

What this means:

Bring Router → to create the app
Bring get → to define GET routes
Bring SocketAddr → to define IP + port

🐍 FastAPI equivalent:

from fastapi import FastAPI

🔹 Step 2: Async Main Function

#[tokio::main]
async fn main() {

What this means:

Rust normally doesn’t support async in main, so we use Tokio (an async runtime).

👉 This is like saying:

“Run this program using async engine”

🐍 FastAPI equivalent:

import asyncio

async def main():
    ...

asyncio.run(main())

🔹 Step 3: Create the App

let app = Router::new()
    .route("/", get(root));

What this means:

Create a new app (Router::new())
Add a route /
When someone sends a GET request, call root

🐍 FastAPI equivalent:

app = FastAPI()

@app.get("/")
async def root():
    return "Hello"

👉 Same idea, different syntax.

🔹 Step 4: Define Address

let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

What this means:

Your server will run on:

http://127.0.0.1:3000

🐍 FastAPI equivalent:

uvicorn.run(app, host="127.0.0.1", port=3000)

🔹 Step 5: Bind the Server

let listener = tokio::net::TcpListener::bind(addr).await.unwrap();

What this means:

Open port 3000
Start listening for incoming requests

Think of it like:

“Open the door and wait for visitors”

🐍 Python equivalent:

server.bind(("127.0.0.1", 3000))
server.listen()

🔹 Step 6: Start the Server

axum::serve(listener, app).await.unwrap();

What this means:

Take incoming requests from listener
Pass them to your app (Router)
Run forever

🐍 FastAPI equivalent:

uvicorn.run(app)

🔹 Step 7: Handler Function

async fn root() -> &'static str {
    "Hello, Axum! Hello guys how are you!!!"
}

What this means:

When someone visits /, this function runs and returns a response.

🐍 FastAPI equivalent:

@app.get("/")
async def root():
    return "Hello, Axum!"

🔁 Full Request Flow

Here’s what happens when you open your browser:

Browser → http://127.0.0.1:3000/
        ↓
TcpListener (listening)
        ↓
Axum Server
        ↓
Router matches "/"
        ↓
root() function runs
        ↓
Response sent back

Now Full fastapi code:

from fastapi import FastAPI
import uvicorn

# 1. Create app
app = FastAPI()

# 2. Create route
@app.get("/")
async def root():
    return "Hello, Axum! Hello guys how are you!!!"

# 3. Run server
if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=3000)

🔹 Key Difference (important)

👉 In Axum (Rust):

You manually:
bind address
create listener
start server

👉 In FastAPI (Python):

uvicorn.run() does everything for you

Simple Mental Model

Concept	Axum	FastAPI
App	`Router::new()`	`FastAPI()`
Route	`.route("/", get(...))`	`@app.get("/")`
Handler	`async fn root()`	`async def root()`
Server start	`axum::serve(...)`	`uvicorn.run()`
Address	`SocketAddr`	host + port

Final Summary

This whole Axum program means:

“Create a web server that listens on port 3000, and when someone visits /, return a simple message.”

If you're already comfortable with FastAPI, you're much closer to mastering Axum than you think. The concepts are the same — Rust just makes things more explicit and safe.

Forem: Syeed Talha

Implementing POST and GET in Axum using in-memory storage.

Step 1 — Create the project

Step 2 — The full main.rs

Step 3 — Run and test

Key concepts to remember

🔹 Debug

🔹 Serialize

🔹 Deserialize

🔹 Clone

Why all together?

Arc<Mutex<Vec<User>>> — The shared notebook

State(...) — The magic backpack

One more thing — why does Rust force you to think about this?

Beginner’s Guide to Axum: Path, Query & JSON

What We Are Building

Required Dependencies

1. Path Parameters

Example URL

Code

2. Query Parameters

Example URL

Struct

Code

3. JSON Request & Response (POST)

Request JSON

Structs

Code

Full Working Code (Copy & Run)

How to Run

Test Path

Test Query

Test POST (Important)

What You Learned

Understand Your First Axum Server by Comparing with FastAPI

🧩 The Full Code

🧠 Big Picture

🔹 Step 1: Importing Things

What this means:

🐍 FastAPI equivalent:

🔹 Step 2: Async Main Function

What this means:

🐍 FastAPI equivalent:

🔹 Step 3: Create the App

What this means:

🐍 FastAPI equivalent:

🔹 Step 4: Define Address

What this means:

🐍 FastAPI equivalent:

🔹 Step 5: Bind the Server

What this means:

🐍 Python equivalent:

🔹 Step 6: Start the Server

What this means:

🐍 FastAPI equivalent:

🔹 Step 7: Handler Function

What this means:

🐍 FastAPI equivalent:

🔁 Full Request Flow

Now Full fastapi code:

Simple Mental Model

Final Summary

Step 2 — The full `main.rs`

🔹 `Debug`

🔹 `Serialize`

🔹 `Deserialize`

🔹 `Clone`

`Arc<Mutex<Vec<User>>>` — The shared notebook

`State(...)` — The magic backpack