Building a REST API is one of the most common ways to use Go for backend development.

Go is well suited for REST APIs because it provides strong performance, simple syntax, built-in HTTP support, excellent concurrency, and easy deployment.

In this guide, you will build a complete beginner-friendly REST API using Go. You will learn how to create routes, handle HTTP methods, work with JSON, create CRUD endpoints, return proper status codes, validate requests, handle errors, organize your project, and test your API.

---

What Is a REST API?

REST stands for:

Representational State Transfer

A REST API allows clients such as:

• mobile apps
• web apps
• desktop applications
• other backend services

to communicate with a server using HTTP.

For example, a client might request:

GET /users

The server processes the request and returns JSON:

[
  {
    "id": 1,
    "name": "John",
    "email": "john@example.com"
  }
]

---

Common HTTP Methods in REST APIs

REST APIs commonly use these HTTP methods:

GET
POST
PUT
PATCH
DELETE

Their typical purpose is:

GET     → Read data
POST    → Create data
PUT     → Replace/update data
PATCH   → Partially update data
DELETE  → Delete data

For a user API, routes may look like:

GET    /users
GET    /users/1
POST   /users
PUT    /users/1
DELETE /users/1

---

Why Use Go for REST APIs?

Go is a strong choice for building REST APIs because it provides:

• built-in HTTP server support
• strong performance
• static typing
• fast compilation
• simple deployment
• goroutines for concurrency
• excellent JSON support
• clean standard library
• good database support

You can build a functional API using only Go’s standard library.

---

Step 1: Install Go

First, install Go on your system.

Check the installation:

go version

You should see output similar to:

go version go1.x.x

---

Step 2: Create a New Project

Create a directory:

mkdir go-rest-api

Enter it:

cd go-rest-api

Initialize a Go module:

go mod init go-rest-api

Create:

main.go

Your project will look like:

go-rest-api/
│
├── go.mod
└── main.go

---

Step 3: Create Your First HTTP Server

Add this code to main.go:

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Go REST API is running")
}

func main() {
    http.HandleFunc("/", homeHandler)

    fmt.Println("Server running on http://localhost:8080")

    err := http.ListenAndServe(":8080", nil)

    if err != nil {
        fmt.Println("Server error:", err)
    }
}

Run:

go run main.go

Open:

http://localhost:8080

You should see:

Go REST API is running

---

Understanding http.HandleFunc

This line:

http.HandleFunc("/", homeHandler)

connects the / route to:

homeHandler

Whenever a user opens:

/

Go executes:

func homeHandler(w http.ResponseWriter, r *http.Request)

---

Understanding http.ResponseWriter

http.ResponseWriter is used to send data back to the client.

Example:

fmt.Fprintln(w, "Hello")

---

Understanding *http.Request

The request contains information such as:

r.Method
r.URL
r.Header
r.Body

For example:

fmt.Println(r.Method)

may print:

GET

---

Step 4: Create a User Model

Let’s create a simple REST API for users.

Define:

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

The JSON tags:

json:"id"
json:"name"
json:"email"

control how fields appear in JSON.

---

Step 5: Create Temporary Data Storage

For this beginner example, we will store users in memory.

var users = []User{
    {
        ID:    1,
        Name:  "John",
        Email: "john@example.com",
    },
    {
        ID:    2,
        Name:  "Alice",
        Email: "alice@example.com",
    },
}

In a production application, you would normally use a database such as PostgreSQL or MySQL.

---

Step 6: Return JSON Response

Import:

"encoding/json"

Create a handler:

func getUsers(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")

    json.NewEncoder(w).Encode(users)
}

Register the route:

http.HandleFunc("/users", getUsers)

Request:

GET /users

Response:

[
  {
    "id": 1,
    "name": "John",
    "email": "john@example.com"
  },
  {
    "id": 2,
    "name": "Alice",
    "email": "alice@example.com"
  }
]

---

Step 7: Handle HTTP Methods

The /users route may need both:

GET
POST

You can check the method using:

r.Method

Example:

func usersHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {

    case http.MethodGet:
        getUsers(w, r)

    case http.MethodPost:
        createUser(w, r)

    default:
        http.Error(
            w,
            "Method not allowed",
            http.StatusMethodNotAllowed,
        )
    }
}

Now one route can support multiple HTTP methods.

---

Step 8: Create a New User

The client may send:

{
  "name": "David",
  "email": "david@example.com"
}

Create:

func createUser(w http.ResponseWriter, r *http.Request) {
    var user User

    err := json.NewDecoder(r.Body).Decode(&user)

    if err != nil {
        http.Error(
            w,
            "Invalid request body",
            http.StatusBadRequest,
        )
        return
    }

    user.ID = len(users) + 1

    users = append(users, user)

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)

    json.NewEncoder(w).Encode(user)
}

Request:

POST /users

Body:

{
  "name": "David",
  "email": "david@example.com"
}

Response:

{
  "id": 3,
  "name": "David",
  "email": "david@example.com"
}

Status:

201 Created

---

Step 9: Validate Incoming Data

Never trust client input.

For example:

if user.Name == "" || user.Email == "" {
    http.Error(
        w,
        "Name and email are required",
        http.StatusBadRequest,
    )
    return
}

Now the API rejects invalid data.

---

Step 10: Create a Standard JSON Error Response

Using http.Error() is fine for small examples, but production APIs often return JSON errors.

Create:

type ErrorResponse struct {
    Error string `json:"error"`
}

Helper:

func sendError(
    w http.ResponseWriter,
    message string,
    status int,
) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)

    json.NewEncoder(w).Encode(
        ErrorResponse{
            Error: message,
        },
    )
}

Use:

sendError(
    w,
    "User not found",
    http.StatusNotFound,
)

Response:

{
  "error": "User not found"
}

---

Step 11: Get a User by ID

We want:

GET /users/1

With the standard library, we can manually parse the URL path.

Example:

func userHandler(w http.ResponseWriter, r *http.Request) {
    idString := strings.TrimPrefix(
        r.URL.Path,
        "/users/",
    )

    id, err := strconv.Atoi(idString)

    if err != nil {
        sendError(
            w,
            "Invalid user ID",
            http.StatusBadRequest,
        )
        return
    }

    switch r.Method {

    case http.MethodGet:
        getUserByID(w, id)

    case http.MethodPut:
        updateUser(w, r, id)

    case http.MethodDelete:
        deleteUser(w, id)

    default:
        sendError(
            w,
            "Method not allowed",
            http.StatusMethodNotAllowed,
        )
    }
}

Remember to import:

"strconv"
"strings"

---

Step 12: Find a User by ID

Create:

func getUserByID(w http.ResponseWriter, id int) {
    for _, user := range users {

        if user.ID == id {

            w.Header().Set(
                "Content-Type",
                "application/json",
            )

            json.NewEncoder(w).Encode(user)

            return
        }
    }

    sendError(
        w,
        "User not found",
        http.StatusNotFound,
    )
}

Request:

GET /users/1

Response:

{
  "id": 1,
  "name": "John",
  "email": "john@example.com"
}

---

Step 13: Update a User

We want:

PUT /users/1

Body:

{
  "name": "John Updated",
  "email": "john.updated@example.com"
}

Create:

func updateUser(
    w http.ResponseWriter,
    r *http.Request,
    id int,
) {

    var updatedUser User

    err := json.NewDecoder(
        r.Body,
    ).Decode(&updatedUser)

    if err != nil {
        sendError(
            w,
            "Invalid request body",
            http.StatusBadRequest,
        )
        return
    }

    for i, user := range users {

        if user.ID == id {

            updatedUser.ID = id

            users[i] = updatedUser

            w.Header().Set(
                "Content-Type",
                "application/json",
            )

            json.NewEncoder(w).Encode(
                updatedUser,
            )

            return
        }
    }

    sendError(
        w,
        "User not found",
        http.StatusNotFound,
    )
}

---

Step 14: Delete a User

We want:

DELETE /users/1

Create:

func deleteUser(w http.ResponseWriter, id int) {
    for i, user := range users {

        if user.ID == id {

            users = append(
                users[:i],
                users[i+1:]...,
            )

            w.WriteHeader(
                http.StatusNoContent,
            )

            return
        }
    }

    sendError(
        w,
        "User not found",
        http.StatusNotFound,
    )
}

Successful response:

204 No Content

---

Complete CRUD REST API

Now let’s combine everything.

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "strconv"
    "strings"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

type ErrorResponse struct {
    Error string `json:"error"`
}

var users = []User{
    {
        ID:    1,
        Name:  "John",
        Email: "john@example.com",
    },
    {
        ID:    2,
        Name:  "Alice",
        Email: "alice@example.com",
    },
}

func sendError(
    w http.ResponseWriter,
    message string,
    status int,
) {
    w.Header().Set(
        "Content-Type",
        "application/json",
    )

    w.WriteHeader(status)

    json.NewEncoder(w).Encode(
        ErrorResponse{
            Error: message,
        },
    )
}

func getUsers(
    w http.ResponseWriter,
    r *http.Request,
) {
    w.Header().Set(
        "Content-Type",
        "application/json",
    )

    json.NewEncoder(w).Encode(users)
}

func createUser(
    w http.ResponseWriter,
    r *http.Request,
) {
    var user User

    err := json.NewDecoder(
        r.Body,
    ).Decode(&user)

    if err != nil {
        sendError(
            w,
            "Invalid request body",
            http.StatusBadRequest,
        )
        return
    }

    if user.Name == "" || user.Email == "" {
        sendError(
            w,
            "Name and email are required",
            http.StatusBadRequest,
        )
        return
    }

    user.ID = len(users) + 1

    users = append(users, user)

    w.Header().Set(
        "Content-Type",
        "application/json",
    )

    w.WriteHeader(
        http.StatusCreated,
    )

    json.NewEncoder(w).Encode(user)
}

func getUserByID(
    w http.ResponseWriter,
    id int,
) {
    for _, user := range users {

        if user.ID == id {

            w.Header().Set(
                "Content-Type",
                "application/json",
            )

            json.NewEncoder(w).Encode(user)

            return
        }
    }

    sendError(
        w,
        "User not found",
        http.StatusNotFound,
    )
}

func updateUser(
    w http.ResponseWriter,
    r *http.Request,
    id int,
) {
    var updatedUser User

    err := json.NewDecoder(
        r.Body,
    ).Decode(&updatedUser)

    if err != nil {
        sendError(
            w,
            "Invalid request body",
            http.StatusBadRequest,
        )
        return
    }

    for i, user := range users {

        if user.ID == id {

            updatedUser.ID = id

            users[i] = updatedUser

            w.Header().Set(
                "Content-Type",
                "application/json",
            )

            json.NewEncoder(w).Encode(
                updatedUser,
            )

            return
        }
    }

    sendError(
        w,
        "User not found",
        http.StatusNotFound,
    )
}

func deleteUser(
    w http.ResponseWriter,
    id int,
) {
    for i, user := range users {

        if user.ID == id {

            users = append(
                users[:i],
                users[i+1:]...,
            )

            w.WriteHeader(
                http.StatusNoContent,
            )

            return
        }
    }

    sendError(
        w,
        "User not found",
        http.StatusNotFound,
    )
}

func usersHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    switch r.Method {

    case http.MethodGet:
        getUsers(w, r)

    case http.MethodPost:
        createUser(w, r)

    default:
        sendError(
            w,
            "Method not allowed",
            http.StatusMethodNotAllowed,
        )
    }
}

func userHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    idString := strings.TrimPrefix(
        r.URL.Path,
        "/users/",
    )

    id, err := strconv.Atoi(idString)

    if err != nil {
        sendError(
            w,
            "Invalid user ID",
            http.StatusBadRequest,
        )
        return
    }

    switch r.Method {

    case http.MethodGet:
        getUserByID(w, id)

    case http.MethodPut:
        updateUser(w, r, id)

    case http.MethodDelete:
        deleteUser(w, id)

    default:
        sendError(
            w,
            "Method not allowed",
            http.StatusMethodNotAllowed,
        )
    }
}

func main() {
    http.HandleFunc(
        "/users",
        usersHandler,
    )

    http.HandleFunc(
        "/users/",
        userHandler,
    )

    fmt.Println(
        "Server running on http://localhost:8080",
    )

    err := http.ListenAndServe(
        ":8080",
        nil,
    )

    if err != nil {
        fmt.Println(
            "Server error:",
            err,
        )
    }
}

---

API Endpoints

Your API now supports:

GET    /users
POST   /users
GET    /users/{id}
PUT    /users/{id}
DELETE /users/{id}

This is a complete basic CRUD API.

---

Testing the API with curl

Get All Users

curl http://localhost:8080/users

---

Get One User

curl http://localhost:8080/users/1

---

Create User

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

---

Update User

curl -X PUT http://localhost:8080/users/1 \
-H "Content-Type: application/json" \
-d '{
  "name": "John Updated",
  "email": "john.updated@example.com"
}'

---

Delete User

curl -X DELETE http://localhost:8080/users/1

---

Testing with Postman

You can also use Postman.

Create requests such as:

GET http://localhost:8080/users

or:

POST http://localhost:8080/users

Select:

Body → raw → JSON

Then add:

{
  "name": "David",
  "email": "david@example.com"
}

---

Important HTTP Status Codes

A REST API should return meaningful status codes.

Common codes include:

200 OK
201 Created
204 No Content
400 Bad Request
401 Unauthorized
403 Forbidden
404 Not Found
409 Conflict
422 Unprocessable Content
500 Internal Server Error

For example:

w.WriteHeader(http.StatusCreated)

means:

201 Created

---

Adding Query Parameters

Suppose you want:

GET /users?name=John

Read:

name := r.URL.Query().Get("name")

Example:

func usersHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    name := r.URL.Query().Get("name")

    fmt.Println(name)
}

---

Pagination Example

A real API may support:

GET /users?page=1&limit=10

Read:

page := r.URL.Query().Get("page")
limit := r.URL.Query().Get("limit")

In production, convert the values to integers and validate them.

---

Sorting and Filtering

A larger API might support:

GET /users?sort=name

or:

GET /products?category=mobile

or:

GET /products?min_price=100&max_price=1000

Always validate values before using them in database queries.

---

Middleware in Go REST API

Middleware runs before or after a handler.

It can be used for:

Logging
Authentication
Authorization
CORS
Rate limiting
Request IDs
Recovery
Metrics

Example:

func loggingMiddleware(
    next http.Handler,
) http.Handler {

    return http.HandlerFunc(
        func(
            w http.ResponseWriter,
            r *http.Request,
        ) {

            fmt.Println(
                r.Method,
                r.URL.Path,
            )

            next.ServeHTTP(w, r)
        },
    )
}

---

Use a Custom http.ServeMux

Instead of relying on the default global router, you can create your own:

mux := http.NewServeMux()

Then:

mux.HandleFunc(
    "/users",
    usersHandler,
)

Start:

http.ListenAndServe(
    ":8080",
    mux,
)

This makes routing easier to manage as your application grows.

---

Better Server Configuration

For production applications, avoid only using:

http.ListenAndServe()

Instead, create an HTTP server:

server := &http.Server{
    Addr:         ":8080",
    Handler:      mux,
    ReadTimeout:  10 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  60 * time.Second,
}

Then:

err := server.ListenAndServe()

Timeouts help protect your server from slow or stuck connections.

---

Connecting the API to PostgreSQL

Our current API stores data in:

var users []User

This means all data disappears when the server restarts.

A real application normally uses a database.

For example:

Go REST API
     |
     v
PostgreSQL

You could install pgx:

go get github.com/jackc/pgx/v5

Then use PostgreSQL for operations such as:

INSERT
SELECT
UPDATE
DELETE

---

Example PostgreSQL Table

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(150) UNIQUE NOT NULL
);

---

Insert User into PostgreSQL

Conceptually:

query := `
INSERT INTO users (name, email)
VALUES ($1, $2)
RETURNING id
`

err := db.QueryRow(
    context.Background(),
    query,
    user.Name,
    user.Email,
).Scan(&user.ID)

---

Get Users from PostgreSQL

Example:

rows, err := db.Query(
    context.Background(),
    `
    SELECT id, name, email
    FROM users
    ORDER BY id
    `,
)

Then iterate:

for rows.Next() {

    var user User

    err := rows.Scan(
        &user.ID,
        &user.Name,
        &user.Email,
    )

    if err != nil {
        // handle error
    }

    users = append(users, user)
}

---

Use Parameterized Queries

Never build SQL like this:

query :=
    "SELECT * FROM users WHERE email = '" +
        email +
        "'"

Use parameters:

query :=
    "SELECT id, name, email FROM users WHERE email = $1"

Then:

db.QueryRow(
    context.Background(),
    query,
    email,
)

Parameterized queries help prevent SQL injection.

---

Authentication in a REST API

Most real APIs need authentication.

A common flow is:

Register
   ↓
Login
   ↓
Generate JWT
   ↓
Client stores token
   ↓
Send token with requests
   ↓
Backend verifies token

The client sends:

Authorization: Bearer TOKEN

The backend checks the token before allowing access to protected routes.

---

Never Store Plain-Text Passwords

Bad:

password123

in a database.

Instead, hash passwords.

A commonly used package is:

golang.org/x/crypto/bcrypt

Example:

hashedPassword, err :=
    bcrypt.GenerateFromPassword(
        []byte(password),
        bcrypt.DefaultCost,
    )

---

CORS

If your frontend and backend are running on different origins, you may need CORS configuration.

Example:

Frontend:
https://example.com

Backend:
https://api.example.com

CORS determines whether a browser can make requests from one origin to another.

Configure it carefully in production.

---

Recommended Project Structure

Once your project grows, avoid putting everything inside main.go.

A practical structure could be:

go-rest-api/
│
├── cmd/
│   └── api/
│       └── main.go
│
├── internal/
│   ├── handlers/
│   │   └── user_handler.go
│   │
│   ├── services/
│   │   └── user_service.go
│   │
│   ├── repositories/
│   │   └── user_repository.go
│   │
│   ├── models/
│   │   └── user.go
│   │
│   ├── middleware/
│   └── database/
│
├── go.mod
├── go.sum
└── README.md

---

Handler Layer

Handlers deal with HTTP.

For example:

func CreateUserHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    // Parse request
    // Call service
    // Return response
}

---

Service Layer

Services contain business logic.

Example:

func CreateUser(
    input CreateUserInput,
) error {
    // Validate
    // Check business rules
    // Call repository

    return nil
}

---

Repository Layer

Repositories communicate with the database.

Example:

func SaveUser(
    user User,
) error {
    // SQL query

    return nil
}

---

API Flow

A well-structured request may flow like:

Client
  |
  v
Router
  |
  v
Handler
  |
  v
Service
  |
  v
Repository
  |
  v
Database

---

Testing Go REST APIs

Go includes excellent built-in testing support.

Use:

testing

and:

net/http/httptest

Example:

func TestGetUsers(
    t *testing.T,
) {
    req := httptest.NewRequest(
        http.MethodGet,
        "/users",
        nil,
    )

    recorder :=
        httptest.NewRecorder()

    getUsers(
        recorder,
        req,
    )

    if recorder.Code != http.StatusOK {
        t.Errorf(
            "expected status 200, got %d",
            recorder.Code,
        )
    }
}

Run:

go test ./...

---

Use the Race Detector

If your API uses goroutines or shared state, use:

go test -race ./...

The race detector helps find unsafe concurrent memory access.

---

Important Problem with Our In-Memory Example

Our example uses:

var users []User

If multiple requests modify this slice concurrently, it can lead to a data race.

For learning, it keeps the example simple.

For real applications, prefer:

• a database
• a mutex around shared memory
• another controlled synchronization strategy

depending on the design.

---

REST API Best Practices

When building production APIs:

• return JSON consistently
• use correct HTTP status codes
• validate request data
• never expose sensitive errors
• use HTTPS
• use authentication
• enforce authorization
• hash passwords
• use parameterized SQL
• configure CORS correctly
• add request timeouts
• add logging
• implement pagination
• add rate limiting where needed
• write tests
• keep secrets in environment variables

---

Example REST API Response Format

Many applications use:

{
  "success": true,
  "message": "User fetched successfully",
  "data": {
    "id": 1,
    "name": "John"
  }
}

Error:

{
  "success": false,
  "message": "User not found"
}

Consistency makes APIs easier for clients to consume.

---

REST API vs GraphQL

REST commonly has multiple endpoints:

GET /users
GET /users/1
GET /products

GraphQL commonly uses one endpoint and lets clients define requested fields.

REST is generally easier for beginners and remains widely used.

---

REST API vs gRPC

REST commonly uses:

HTTP + JSON

gRPC commonly uses:

HTTP/2 + Protocol Buffers

REST is particularly convenient for:

• public APIs
• web clients
• mobile clients
• simple service integrations

gRPC is often attractive for internal service-to-service communication.

---

Should You Use a Framework?

You do not need a framework to build REST APIs in Go.

The standard library provides:

net/http
encoding/json

which are enough for many applications.

However, frameworks and routers can make larger APIs more convenient.

Popular options include:

Gin
Chi
Echo
Fiber

---

Simple Gin REST API Example

Install:

go get github.com/gin-gonic/gin

Example:

package main

import "github.com/gin-gonic/gin"

func main() {
    router := gin.Default()

    router.GET(
        "/users",
        func(c *gin.Context) {

            c.JSON(
                200,
                gin.H{
                    "message": "Users API",
                },
            )
        },
    )

    router.Run(":8080")
}

For beginners, learning net/http first is useful because it teaches the fundamentals behind Go web frameworks.

---

How a REST Request Works

Suppose a mobile app sends:

POST /users

Body:

{
  "name": "David",
  "email": "david@example.com"
}

The backend flow might be:

Client sends request
        ↓
Router matches endpoint
        ↓
Handler decodes JSON
        ↓
Input is validated
        ↓
Service applies business logic
        ↓
Repository saves user
        ↓
Database returns record
        ↓
Handler returns JSON

---

Beginner REST API Roadmap

After completing the basic API in this guide, continue in this order:

1. CRUD APIs
2. PostgreSQL
3. Input validation
4. Authentication
5. JWT
6. Middleware
7. Error handling
8. Pagination
9. Filtering
10. Logging
11. Testing
12. Redis
13. Docker
14. Deployment
15. CI/CD

---

Beginner Project Ideas

Todo API

Build:

POST   /tasks
GET    /tasks
GET    /tasks/:id
PUT    /tasks/:id
DELETE /tasks/:id

---

Blog API

Build:

Users
Posts
Comments
Authentication
Pagination

---

E-Commerce API

Build:

Products
Categories
Users
Cart
Orders
Payments

---

Authentication API

Build:

Register
Login
JWT
Refresh token
Profile
Logout

---

Frequently Asked Questions

Can Go build REST APIs?

Yes. Go has built-in packages such as net/http and encoding/json that make it possible to build REST APIs without a framework.

Do I need Gin for a Go REST API?

No.

You can build a complete REST API using the Go standard library.

Gin can make routing and middleware more convenient for larger projects.

Which database should I use with Go REST APIs?

Common choices include:

PostgreSQL
MySQL
SQLite
MongoDB

PostgreSQL is an excellent general-purpose choice for many applications.

What is CRUD?

CRUD means:

Create
Read
Update
Delete

These operations commonly map to:

POST
GET
PUT/PATCH
DELETE

How do I return JSON in Go?

Use:

json.NewEncoder(w).Encode(data)

and set:

w.Header().Set(
    "Content-Type",
    "application/json",
)

How do I read JSON in Go?

Use:

json.NewDecoder(
    r.Body,
).Decode(&value)

How do I handle route parameters?

With the standard library, you can parse the path yourself or use newer routing patterns depending on your Go version.

Routers such as Gin and Chi also provide convenient path parameter handling.

Should I use a database in my first API?

Not necessarily.

Starting with an in-memory slice helps you understand HTTP and CRUD fundamentals.

Once those concepts are clear, replace the slice with PostgreSQL or another database.

Is Go good for production REST APIs?

Yes.

Go is widely used for production backend services because of its performance, networking support, concurrency model, static typing, and straightforward deployment.

---

Conclusion

Building a REST API with Go is straightforward because Go already includes the core tools required for HTTP development.

You can start with:

http.HandleFunc(
    "/users",
    usersHandler,
)

return JSON using:

json.NewEncoder(w).Encode(data)

decode incoming requests using:

json.NewDecoder(
    r.Body,
).Decode(&request)

and handle methods such as:

GET
POST
PUT
DELETE

A beginner should first build a simple CRUD API using the standard library.

Then gradually add:

PostgreSQL
Validation
Authentication
JWT
Middleware
Logging
Testing
Redis
Docker
Deployment

Once you understand these concepts, you will have the foundation required to build production-ready APIs for mobile applications, websites, SaaS products, microservices, and cloud systems using Go.