DEV Community: Steve Omollo

Building a Simple Task API in Go

Steve Omollo — Mon, 01 Jun 2026 06:44:38 +0000

Previously, we learned how to send and receive JSON data in Go.

One of the next steps in building backend applications is creating APIs with multiple endpoints that can handle different types of requests.

In this tutorial, we will build a simple task API in Go using only the standard library.

By the end, you will understand:

how API endpoints work
how to handle multiple HTTP methods
how to store data in memory using slices
how to send and receive JSON data
how backend APIs manage resources

Prerequisites

To follow along, you should have:

Go installed
basic familiarity with Go syntax
understanding of the net/http package
basic understanding of JSON handling

You can confirm if Go is installed by running:

go version

Step 1 — Create the Project

Create a new folder for the project:

mkdir go-task-api
cd go-task-api

Now initialize a Go module:

go mod init go-task-api

This creates a go.mod file for managing project dependencies.

Step 2 — Create the Server File

Create a file called main.go.

Your project structure should now look like this:

go-task-api/
├─ go.mod
└─ main.go

Step 3 — Write the API

Open main.go and add the following code:

package main

import (
    "encoding/json"
    "net/http"
)

type Task struct {
    ID    int    `json:"id"`
    Title string `json:"title"`
}

var tasks []Task

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

    switch r.Method {

    case http.MethodGet:
        json.NewEncoder(w).Encode(tasks)

    case http.MethodPost:
        var task Task

        err := json.NewDecoder(r.Body).Decode(&task)
        if err != nil {
            http.Error(w, "Invalid JSON", http.StatusBadRequest)
            return
        }

        tasks = append(tasks, task)

        json.NewEncoder(w).Encode(task)

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

func main() {
    http.HandleFunc("/tasks", tasksHandler)

    http.ListenAndServe(":8080", nil)
}

Now let's unpack what is happening.

Understanding the Struct

This struct represents a task:

type Task struct {
    ID    int    `json:"id"`
    Title string `json:"title"`
}

Each task contains:

an ID
a Title

This struct defines the JSON format our API will use.

For example:

{
    "id": 1,
    "title": "Learn Go"
}

Understanding In-Memory Storage

This line:

var tasks []Task

creates a slice that stores tasks in memory.

For now, our data only exists while the server is running.

Once the server stops, the data disappears.

This keeps the tutorial simple before introducing databases later.

Understanding HTTP Methods

This part checks the request method:

switch r.Method

HTTP methods tell the server what action the client wants to perform.

Here, we handle:

Method	Purpose
`GET`	Retrieves tasks
`POST`	Creates tasks

Later, we could also add:

PUT for updating tasks
DELETE for removing tasks

Because, you know, every backend journey eventually leads there.

Handling GET Requests

This section handles fetching tasks:

case http.MethodGet:
    json.NewEncoder(w).Encode(tasks)

When the client sends a GET request:

the server retrieves all tasks
the tasks are converted into JSON
the JSON response is sent back to the client

Handling POST Requests

This section handles creating tasks:

case http.MethodPost:

Inside this block:

var task Task

we create a task variable to store the incoming JSON data.

Then we decode the request body:

json.NewDecoder(r.Body).Decode(&task)

If decoding succeeds, we add the task to the slice:

tasks = append(tasks, task)

Finally, we return the created task as JSON.

Understanding `append`

This line:

tasks = append(tasks, task)

adds a new task to the slice.

Slices in Go are dynamic, that is, they can grow as we add more data.

This allows our API to store multiple tasks.

Understanding Error Handling

This section checks whether the JSON request is valid:

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

If decoding fails:

the server sends an error response
the request stops processing

This helps keep the API stable when invalid data is sent.

Step 4 — Run the Server

Start the application:

go run main.go

The server should now be running on port 8080.

Step 5 — Create a Task

We can create a task using curl.

Run:

curl -X POST http://localhost:8080/tasks \
-H "Content-Type: application/json" \
-d '{"id":1,"title":"Learn Go"}'

You should receive:

{
    "id": 1,
    "title": "Learn Go"
}

Step 6 — Retrieve Tasks

Now retrieve all tasks using:

curl http://localhost:8080/tasks

You should receive:

[
    {
        "id": 1,
        "title": "Learn Go"
    }
]

What Happens When a Request Is Made?

Here's the flow:

The client sends an HTTP request
Go checks the request method
The correct code block runs
Tasks are created or retrieved
JSON responses are returned to the client

This is the foundation of many backend APIs.

Where to Go Next

Now that we have a simple task API, we could extend it by adding:

PUT requests
DELETE requests
route parameters
databases
request validation
authentication

This is where backend applications start becoming much more powerful and realistic.

Final Thoughts

We started with simple HTTP servers and gradually built a working task API.

Along the way, we learned about:

HTTP methods
JSON encoding
JSON decoding
slices
request handling
API design

These are the foundational backend development concepts that appear in many real-world applications.

Thanks for reading!

Happy coding!

Handling JSON Requests in Go

Steve Omollo — Sat, 23 May 2026 11:59:27 +0000

Previously, we learned how to return JSON responses from a Go server.

But APIs do not only send data — they also receive it.

Frontend applications, mobile apps, and clients commonly send JSON data to servers through HTTP requests.

In this tutorial, we will learn how to handle JSON requests in Go by decoding request bodies into structs using Go's standard library.

By the end, you will understand:

how JSON request bodies work
how to decode JSON in Go
how POST requests work
how to process incoming client data

Prerequisites

To follow along, you should have:

Go installed
basic familiarity with Go syntax
understanding of the net/http package
basic understanding of JSON responses

You can confirm if Go is installed by running:

go version

Step 1 — Create the Project

Create a new folder for the project:

mkdir go-json-requests
cd go-json-requests

Now initialize a Go module:

go mod init go-json-requests

This creates a go.mod file for managing project dependencies.

Step 2 — Create the Server File

Create a file called main.go.

Your project structure should now look like this:

go-json-requests/
├─ go.mod
└─ main.go

Step 3 — Write the Server

Open main.go and add the following code:

package main

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

type User struct {
    Name string `json:"name"`
}

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

    err := json.NewDecoder(r.Body).Decode(&user)
    if err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }

    fmt.Fprintf(w, "Hello, %s!\n", user.Name)
}

func main() {
    http.HandleFunc("/user", userHandler)

    fmt.Println("Server running on :8080")

    http.ListenAndServe(":8080", nil)
}

Now let's unpack what is happening.

Understanding POST Requests

In the previous examples, we mainly worked with routes that returned data.

This time, the client sends data to the server.

This commonly happens using a POST request.

POST requests are used when:

submitting forms
sending JSON data
creating resources
uploading information to a server

Understanding the Struct

This struct defines the shape of the JSON data we expect:

type User struct {
    Name string `json:"name"`
}

If the client sends:

{
  "name": "Steve"
}

Go can decode that JSON into the struct.

The json:"name" tag tells Go which JSON field maps to the struct field.

Understanding Request Bodies

When a client sends data to a server, the data is stored inside the request body.

In Go, we access it using:

r.Body

The Body contains the incoming JSON data from the client.

Decoding JSON Requests

This line is the heart of the server:

json.NewDecoder(r.Body).Decode(&user)

Here's what happens:

NewDecoder(r.Body) reads the incoming request body
Decode(&user) converts the JSON into the struct
&user passes a pointer so Go can modify the struct value

After decoding, the user variable contains the client data.

So Why Do We Use `&user`?

You may notice this part:

&user

The & symbol means:

"Use the memory address of this variable."

The decoder needs direct access to the struct so it can fill in the fields with incoming JSON data.

Without the pointer, decoding would not work correctly.

Understanding Error Handling

This section checks whether the JSON request is valid:

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

If decoding fails:

the server sends an error response
the request stops processing

This helps prevent invalid client data from crashing the application.

Step 4 — Run the Server

Start the application:

go run main.go

You should see:

Server running on :8080

Step 5 — Test the API

This server expects a POST request containing JSON data.

We can test it using curl.

curl -X POST http://localhost:8080/user \
-H "Content-Type: application/json" \
-d '{"name":"Steve"}'

You should receive:

Hello, Steve!

What Happens When a Request Is Made?

Here's the flow:

The client sends a POST request
JSON data is placed inside the request body
Go reads the request body
The JSON is decoded into a struct
The server processes the data
A response is sent back to the client

This is the foundation of many real-world APIs.

Where to Go Next

Now that we can decode JSON requests, we could extend this server by adding:

multiple API endpoints
JSON responses
CRUD operations — again, because every backend journey eventually leads there
databases
request validation
authentication

This is where backend development starts becoming much more interactive and dynamic.

Final Thoughts

We started with a simple server that only returned data.

Now our server can also receive and process JSON requests from clients.

Along the way, we learned about:

POST requests
request bodies
JSON decoding
structs
pointers
error handling

These concepts are essential when building APIs in Go.

Thanks for reading!

Happy coding!

Returning JSON Responses in Go

Steve Omollo — Fri, 15 May 2026 20:10:30 +0000

In the previous tutorial, we built a simple HTTP server in Go that returned plain text responses.

While that works, most modern applications communicate using JSON.

Frontend applications, mobile apps, and APIs commonly exchange data in JSON format.

In this tutorial, we will learn how to return JSON responses from a Go server using Go's standard library.

By the end, you will understand:

how JSON responses work in Go
how to create structs
how to encode data into JSON
how to send JSON from an HTTP server

Prerequisites

To follow along, you should have:

Go installed
basic familiarity with Go syntax
understanding of the net/http package

You can confirm if Go is installed by running:

go version

Step 1 — Create the Project

Create a new folder for the project:

mkdir go-json-server
cd go-json-server

Now initialize a Go module:

go mod init go-json-server

This creates a go.mod file for managing project dependencies.

Step 2 — Create the Server File

Create a file called main.go.

Your project structure should now look like this:

go-json-server/
├── go.mod
└── main.go

Step 3 — Write the JSON Server

Open main.go and write this:

package main

import (
    "encoding/json"
    "net/http"
)

type Message struct {
    Text string `json:"text"`
}

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

    response := Message{
        Text: "Hello from Go!",
    }

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

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

    http.ListenAndServe(":8080", nil)
}

Now let's unpack what is happening.

Understanding the Imports

import (
    "encoding/json"
    "net/http"
)

We imported two packages:

net/http — used for creating the HTTP server
encoding/json — used for converting Go data into JSON

The encoding/json package is part of Go's standard library, so we do not need to install anything extra.

Understanding Structs

This part:

type Message struct {
    Text string `json:"text"`
}

defines a struct.

Structs are used to group related data together.

In this example:

Message is the struct name
Text is a field inside the struct

We later use this struct to create JSON responses.

Why is `Text` Capitalized?

You may notice that Text starts with an uppercase letter.

In Go, fields must begin with uppercase letters to be exported.

The JSON encoder can only access exported fields.

For example, this would not work correctly:

type Message struct {
    text string
}

because text is unexported.

This is a very important concept when working with JSON in Go.

Understanding JSON Tags

This part:

`json:"text"`

is called a JSON tag.

JSON tags control how fields appear in the JSON response.

Our Go field is named:

Text

but the JSON output becomes:

{
  "text": "Hello from Go!"
}

This allows us to keep Go naming conventions while returning clean JSON responses.

Understanding Response Headers

Inside the handler, we set a response header:

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

Headers provide additional information about the HTTP response.

Here, we tell the client:

"This response contains JSON data."

This is standard practice when building APIs.

Creating the Response Data

Inside the handler, we create a struct value:

response := Message{
    Text: "Hello from Go!",
}

This creates the data we want to send back to the client.

Encoding JSON Responses

This line converts the Go struct into JSON:

json.NewEncoder(w).Encode(response)

Here's what happens:

NewEncoder(w) creates a JSON encoder
w represents the HTTP response
Encode(response) converts the struct into JSON and sends it to the client

This is one of the most common ways to return JSON in Go web servers.

Step 4 — Run the Server

Start the application:

go run main.go

The server should now be running on port 8080.

Step 5 — Test the Server

Open your browser and visit:

http://localhost:8080

You should see:

{
  "text": "Hello from Go!"
}

Testing with curl

You can also test the server from the terminal using curl:

curl localhost:8080

You should receive:

{
  "text": "Hello from Go!"
}

What Happens When a Request Is Made?

Here's the flow:

The client sends an HTTP request
Go matches the route
The handler function runs
A struct is created
The struct is converted into JSON
The JSON response is sent back to the client

This is the foundation of many backend APIs.

Where to Go Next

Now that we can return JSON responses, we could extend this server by adding:

multiple API routes
dynamic JSON responses
request body handling
JSON decoding
CRUD operations — because, you know, every backend journey eventually leads there
databases

This is where backend development starts becoming more interactive and powerful.

Final Thoughts

We started with a plain text HTTP server, evolved it into a simple JSON API.

Along the way, we learned about:

structs
JSON encoding
response headers
API responses

These concepts form the foundation of modern backend development in Go.

Thanks for reading!

Happy coding!

Building a Simple Web Server in Go

Steve Omollo — Wed, 13 May 2026 09:29:31 +0000

Have you ever wondered how web servers work behind the scenes?

One of the best things about Go is that you can create a working HTTP server with a few lines of code. The standard library already gives us everything we need to start serving web requests without installing any frameworks.

In this tutorial, we will be building a simple web server in Go that:

listens on port 8080
responds to browser requests
serves different routes
returns simple text responses

By the end, you will understand the basics of how Go handles HTTP requests and responses.

Prerequisites

To follow along, you should have:

Go installed
basic familiarity with the terminal
beginner-level Go syntax knowledge

You can confirm if Go is installed by running:

go version

Step 1 — Create the Project

Create a new folder for the project:

mkdir simple-go-server
cd simple-go-server

Now initialize a Go module:

go mod init simple-go-server

This creates a go.mod file that helps Go manage dependencies for the project.

Step 2 — Create the Server File

Create a file called main.go.

Your project should now look like this:

simple-go-server/
├── go.mod
└── main.go

Step 3 — Write the HTTP Server

Open main.go and add the following code:

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello from Go!")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "This is the about page.")
}

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

    fmt.Println("Server running on :8080")

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        fmt.Println("Error starting server:", err)
    }
}

Now let's unpack this.

Understanding the Imports

import (
    "fmt"
    "net/http"
)

We imported two packages:

fmt - is used for printing messages
net/http - is Go's built-in package for creating HTTP servers

The net/http package is part of Go's standard library, which means we don't need to install anything extra.

Understanding Handlers

This function:

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

is called a handler.

Handlers are functions that respond to incoming HTTP requests.

The parameters mean:

Parameter	Purpose
`http.ResponseWriter`	Used to send data back to the client
`*http.Request`	Contains information about the incoming request

Inside the handler, we write a response:

fmt.Fprintln(w, "Hello from Go!")

This sends text back to the browser.

Understanding Routes

Here:

http.HandleFunc("/", homeHandler)

we tell Go:

"When someone visits /, run the homeHandler function."

And here:

http.HandleFunc("/about", aboutHandler)

we register another route.

Now our server has two endpoints:

Route	Response
`/`	Hello from Go!
`/about`	This is the about page.

After registering routes, the final step is starting the server and listening for incoming requests.

Starting the Server

This line starts the web server:

http.ListenAndServe(":8080", nil)

The :8080 means:

"Listen for incoming requests on port 8080."

The nil tells Go to use the default request multiplexer.

Step 4 — Run the Server

Start the application:

go run main.go

You should see:

Server running on :8080

Step 5 — Test the Server

Open your browser and visit:

http://localhost:8080

You should see:

Hello from Go!

Now try:

http://localhost:8080/about

You should see:

This is the about page.

Testing with curl

You can also test the server from the terminal using curl.

For the home route:

curl localhost:8080

For the about route:

curl localhost:8080/about

Here's basically what happens when you visit a route:

Your browser sends an HTTP request
Go receives the request
Go checks which route matches
The correct handler runs
A response is sent back to the browser

This is the foundation of most backend web applications.

Where to Go Next

Our server is very simple, but from here you could add:

JSON responses
HTML templates
middleware
databases
REST APIs — because eventually, everyone builds one.

This is one reason many developers enjoy Go for backend development — you can start small and gradually build more complex systems while keeping the code readable.

Final Thoughts

Go makes it incredibly easy to get started with backend development.

With a few lines of code, we created a working HTTP server capable of handling multiple routes and serving responses to clients.

If you are learning backend development, understanding the net/http package is a great foundation before moving into larger frameworks and architectures.

Thanks for reading!

Happy coding!

DEV Community: Steve Omollo

Building a Simple Task API in Go

Prerequisites

Step 1 — Create the Project

Step 2 — Create the Server File

Step 3 — Write the API

Understanding the Struct

Understanding In-Memory Storage

Understanding HTTP Methods

Handling GET Requests

Handling POST Requests

Understanding append

Understanding Error Handling

Step 4 — Run the Server

Step 5 — Create a Task

Step 6 — Retrieve Tasks

What Happens When a Request Is Made?

Where to Go Next

Final Thoughts

Handling JSON Requests in Go

Prerequisites

Step 1 — Create the Project

Step 2 — Create the Server File

Step 3 — Write the Server

Understanding POST Requests

Understanding the Struct

Understanding Request Bodies

Decoding JSON Requests

So Why Do We Use &user?

Understanding Error Handling

Step 4 — Run the Server

Step 5 — Test the API

What Happens When a Request Is Made?

Where to Go Next

Final Thoughts

Returning JSON Responses in Go

Prerequisites

Step 1 — Create the Project

Step 2 — Create the Server File

Step 3 — Write the JSON Server

Understanding the Imports

Understanding Structs

Why is Text Capitalized?

Understanding JSON Tags

Understanding Response Headers

Creating the Response Data

Encoding JSON Responses

Step 4 — Run the Server

Step 5 — Test the Server

Testing with curl

What Happens When a Request Is Made?

Where to Go Next

Final Thoughts

Building a Simple Web Server in Go

Prerequisites

Step 1 — Create the Project

Step 2 — Create the Server File

Step 3 — Write the HTTP Server

Understanding the Imports

Understanding Handlers

Understanding Routes

Starting the Server

Step 4 — Run the Server

Step 5 — Test the Server

Testing with curl

Where to Go Next

Final Thoughts

Understanding `append`

So Why Do We Use `&user`?

Why is `Text` Capitalized?