Go makes it surprisingly easy to build web servers.

Unlike many programming languages that usually depend on large frameworks for basic web functionality, Go includes a powerful HTTP package in its standard library.

Using the built-in net/http package, you can create a working web server with only a few lines of code.

In this complete beginner-friendly guide, you will learn how to build a web server in Go, create routes, handle requests, return HTML and JSON, serve static files, use middleware, configure timeouts, test handlers, and prepare a server for production.

---

What Is a Web Server?

A web server is a program that listens for incoming HTTP requests and sends back HTTP responses.

For example, when a browser requests:

http://localhost:8080

the server receives the request and may return:

<h1>Hello from Go</h1>

The basic flow looks like this:

Browser or Client
       |
       | HTTP Request
       v
   Go Web Server
       |
       | HTTP Response
       v
Browser or Client

A web server can return:

• HTML pages
• JSON data
• text
• images
• CSS
• JavaScript files
• downloaded files
• API responses

---

Why Use Go for Web Servers?

Go is especially well suited for server-side development.

Some of its biggest advantages include:

• excellent built-in HTTP support
• high performance
• simple syntax
• fast compilation
• built-in concurrency
• efficient networking
• straightforward deployment
• static typing
• strong standard library

You can build a functional HTTP server without installing any external dependency.

---

The net/http Package

Go’s main HTTP package is:

net/http

Import it like this:

import "net/http"

It provides the tools required to:

• start HTTP servers
• register routes
• handle requests
• write responses
• work with headers
• serve files
• build middleware
• configure custom servers

---

Step 1: Create a New Go Project

Create a directory:

mkdir go-web-server

Move into it:

cd go-web-server

Initialize a Go module:

go mod init go-web-server

Create a file:

main.go

Your project should now look like:

go-web-server/
│
├── go.mod
└── main.go

---

Step 2: Create Your First Web Server

Add the following code to main.go:

package main

import (
    "fmt"
    "net/http"
)

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

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

Now open:

http://localhost:8080

You should see:

Hello from Go Web Server

Congratulations. You have created your first Go web server.

---

Understanding http.ListenAndServe

This line starts the server:

http.ListenAndServe(":8080", nil)

The first argument:

:8080

means the server listens on port 8080.

The second argument:

nil

means Go will use the default HTTP request multiplexer.

A multiplexer, or router, decides which handler should process each URL.

---

What Is a Handler?

A handler is a function that receives an HTTP request and writes an HTTP response.

Example:

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

Every HTTP handler usually works with:

http.ResponseWriter

and:

*http.Request

---

Understanding http.ResponseWriter

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

Example:

fmt.Fprintln(
    w,
    "Hello from server",
)

You can also use:

w.Write()

Example:

w.Write(
    []byte("Hello"),
)

---

Understanding *http.Request

*http.Request contains information about the incoming request.

Useful fields include:

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

Example:

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    fmt.Println(
        "Method:",
        r.Method,
    )

    fmt.Println(
        "Path:",
        r.URL.Path,
    )

    fmt.Fprintln(
        w,
        "Request received",
    )
}

---

Step 3: Add Multiple Routes

Most web applications need more than one route.

Example:

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    fmt.Fprintln(w, "Home Page")
}

func aboutHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    fmt.Fprintln(w, "About Page")
}

func contactHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    fmt.Fprintln(w, "Contact Page")
}

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

    http.HandleFunc(
        "/about",
        aboutHandler,
    )

    http.HandleFunc(
        "/contact",
        contactHandler,
    )

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

Now you have:

/          → Home Page
/about     → About Page
/contact   → Contact Page

---

Using http.NewServeMux

For larger applications, using your own router is usually cleaner.

Create one:

mux := http.NewServeMux()

Register routes:

mux.HandleFunc(
    "/",
    homeHandler,
)

Start the server:

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

Complete example:

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    fmt.Fprintln(
        w,
        "Home",
    )
}

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc(
        "/",
        homeHandler,
    )

    fmt.Println(
        "Server running on port 8080",
    )

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

---

Step 4: Handle Different HTTP Methods

A web server may receive:

GET
POST
PUT
PATCH
DELETE

You can inspect the request method using:

r.Method

Example:

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

    case http.MethodGet:
        fmt.Fprintln(
            w,
            "Get users",
        )

    case http.MethodPost:
        fmt.Fprintln(
            w,
            "Create user",
        )

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

---

Step 5: Return HTML

A web server can return HTML directly.

Example:

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

    fmt.Fprint(
        w,
        `
        <html>
            <head>
                <title>Go Web Server</title>
            </head>
            <body>
                <h1>Hello from Go</h1>
                <p>My first Go web server.</p>
            </body>
        </html>
        `,
    )
}

Open the page in a browser and the HTML will be rendered.

---

Step 6: Return JSON

Web servers often return JSON, especially when used as APIs.

Import:

"encoding/json"

Example:

package main

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

type Response struct {
    Message string `json:"message"`
    Status  string `json:"status"`
}

func apiHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    response := Response{
        Message: "Hello from Go API",
        Status:  "success",
    }

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

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

func main() {
    http.HandleFunc(
        "/api",
        apiHandler,
    )

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

Response:

{
  "message": "Hello from Go API",
  "status": "success"
}

---

Step 7: Set HTTP Status Codes

You can set response status codes with:

w.WriteHeader()

Example:

w.WriteHeader(
    http.StatusCreated,
)

This returns:

201 Created

Common status codes include:

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

---

Example 404 Response

func notFoundHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    http.Error(
        w,
        "Page not found",
        http.StatusNotFound,
    )
}

---

Step 8: Read Query Parameters

Suppose the URL is:

/search?q=golang

Read the value with:

query :=
    r.URL.Query().Get("q")

Example:

func searchHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    query :=
        r.URL.Query().Get("q")

    fmt.Fprintf(
        w,
        "Search query: %s",
        query,
    )
}

Request:

/search?q=golang

Response:

Search query: golang

---

Step 9: Read Form Data

Suppose an HTML form sends:

POST /login

You can parse form data:

err := r.ParseForm()

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

Then:

email :=
    r.FormValue("email")

Example:

func loginHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    if r.Method != http.MethodPost {
        http.Error(
            w,
            "Method not allowed",
            http.StatusMethodNotAllowed,
        )
        return
    }

    email :=
        r.FormValue("email")

    fmt.Fprintf(
        w,
        "Login email: %s",
        email,
    )
}

---

Step 10: Serve Static Files

Most websites need files such as:

CSS
JavaScript
Images
Fonts

Create:

static/

Example:

go-web-server/
│
├── static/
│   ├── style.css
│   └── app.js
│
├── go.mod
└── main.go

Create a file server:

fileServer :=
    http.FileServer(
        http.Dir("./static"),
    )

Register it:

http.Handle(
    "/static/",
    http.StripPrefix(
        "/static/",
        fileServer,
    ),
)

Now:

/static/style.css

can serve:

static/style.css

---

Complete Static File Example

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    fmt.Fprint(
        w,
        `
        <!DOCTYPE html>
        <html>
        <head>
            <link
                rel="stylesheet"
                href="/static/style.css"
            >
        </head>
        <body>
            <h1>Hello Go</h1>
        </body>
        </html>
        `,
    )
}

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc(
        "/",
        homeHandler,
    )

    fileServer :=
        http.FileServer(
            http.Dir("./static"),
        )

    mux.Handle(
        "/static/",
        http.StripPrefix(
            "/static/",
            fileServer,
        ),
    )

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

---

Step 11: Serve an HTML File

Instead of writing HTML directly inside Go, you can serve an HTML file.

Create:

templates/index.html

Example:

<!DOCTYPE html>
<html>
<head>
    <title>Go Server</title>
</head>
<body>
    <h1>Welcome to Go Web Server</h1>
</body>
</html>

Then:

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    http.ServeFile(
        w,
        r,
        "./templates/index.html",
    )
}

---

Step 12: Use HTML Templates

Go provides:

html/template

which lets you generate dynamic HTML.

Example template:

<h1>Hello {{.Name}}</h1>

Go code:

package main

import (
    "html/template"
    "net/http"
)

type PageData struct {
    Name string
}

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    tmpl :=
        template.Must(
            template.ParseFiles(
                "templates/index.html",
            ),
        )

    data := PageData{
        Name: "John",
    }

    tmpl.Execute(
        w,
        data,
    )
}

Rendered output:

<h1>Hello John</h1>

---

Step 13: Create Middleware

Middleware runs before or after your main handler.

It is commonly used for:

Logging
Authentication
Authorization
CORS
Rate limiting
Metrics
Recovery
Request IDs

A simple logging middleware:

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 it:

handler :=
    loggingMiddleware(
        mux,
    )

Then:

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

---

Step 14: Create a Custom HTTP Server

For production applications, a custom server gives you more control.

Example:

server := &http.Server{
    Addr:    ":8080",
    Handler: mux,
}

Then:

server.ListenAndServe()

Complete example:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux :=
        http.NewServeMux()

    mux.HandleFunc(
        "/",
        func(
            w http.ResponseWriter,
            r *http.Request,
        ) {
            fmt.Fprintln(
                w,
                "Hello Go",
            )
        },
    )

    server :=
        &http.Server{
            Addr:    ":8080",
            Handler: mux,
        }

    fmt.Println(
        "Server running on port 8080",
    )

    err :=
        server.ListenAndServe()

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

---

Step 15: Configure Timeouts

Timeouts are important for production servers.

Example:

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

Remember to import:

"time"

Timeouts help protect the server from clients that take too long to send or receive data.

---

Step 16: Add Request Logging

You can log important request information:

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

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

            start :=
                time.Now()

            next.ServeHTTP(
                w,
                r,
            )

            log.Printf(
                "%s %s %v",
                r.Method,
                r.URL.Path,
                time.Since(start),
            )
        },
    )
}

This may produce:

GET / 1.2ms
GET /about 900µs
POST /api/users 4.5ms

---

Step 17: Use Environment Variables

Avoid hardcoding configuration.

Instead of:

port := "8080"

you can use:

port :=
    os.Getenv("PORT")

Then provide a fallback:

if port == "" {
    port = "8080"
}

Start:

http.ListenAndServe(
    ":"+port,
    mux,
)

This makes deployment easier.

---

Step 18: Graceful Shutdown

A production server should shut down cleanly.

If you stop a server immediately, active requests may be interrupted.

Go provides:

server.Shutdown(ctx)

Example:

package main

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    mux :=
        http.NewServeMux()

    mux.HandleFunc(
        "/",
        func(
            w http.ResponseWriter,
            r *http.Request,
        ) {
            fmt.Fprintln(
                w,
                "Server is running",
            )
        },
    )

    server :=
        &http.Server{
            Addr:    ":8080",
            Handler: mux,
        }

    go func() {
        fmt.Println(
            "Server running on port 8080",
        )

        err :=
            server.ListenAndServe()

        if err != nil &&
            err != http.ErrServerClosed {

            fmt.Println(
                "Server error:",
                err,
            )
        }
    }()

    quit :=
        make(
            chan os.Signal,
            1,
        )

    signal.Notify(
        quit,
        syscall.SIGINT,
        syscall.SIGTERM,
    )

    <-quit

    ctx, cancel :=
        context.WithTimeout(
            context.Background(),
            5*time.Second,
        )

    defer cancel()

    server.Shutdown(ctx)

    fmt.Println(
        "Server stopped gracefully",
    )
}

This gives active requests time to finish before the server closes.

---

Step 19: Test a Web Handler

Go includes:

net/http/httptest

which allows you to test handlers without starting a real external server.

Example handler:

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

Test:

func TestHomeHandler(
    t *testing.T,
) {
    request :=
        httptest.NewRequest(
            http.MethodGet,
            "/",
            nil,
        )

    recorder :=
        httptest.NewRecorder()

    homeHandler(
        recorder,
        request,
    )

    if recorder.Code !=
        http.StatusOK {

        t.Errorf(
            "expected 200, got %d",
            recorder.Code,
        )
    }
}

Run:

go test ./...

---

Step 20: Organize a Larger Web Server

For small projects, keeping everything in main.go is fine.

For larger applications, use separate packages.

Example:

go-web-server/
│
├── cmd/
│   └── server/
│       └── main.go
│
├── internal/
│   ├── handlers/
│   ├── middleware/
│   ├── services/
│   ├── repositories/
│   └── models/
│
├── templates/
│
├── static/
│
├── go.mod
└── go.sum

This structure separates responsibilities.

---

Handler Layer

Handlers manage HTTP requests.

Example:

func HomeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    // Handle request
}

---

Service Layer

Services contain application logic.

Example:

func GetUser(
    id int,
) (*User, error) {
    // Business logic

    return nil, nil
}

---

Repository Layer

Repositories communicate with databases.

Example:

func FindUser(
    id int,
) (*User, error) {
    // SQL query

    return nil, nil
}

---

Typical Web Server Architecture

A larger application may look like:

Browser
   |
   v
HTTP Server
   |
   v
Router
   |
   v
Middleware
   |
   v
Handler
   |
   v
Service
   |
   v
Repository
   |
   v
Database

---

Connecting a Database

A web server can connect to databases such as:

PostgreSQL
MySQL
SQLite
MongoDB
Redis

For example:

Browser
   |
   v
Go Web Server
   |
   v
PostgreSQL

The server receives the request, queries the database, and returns the result.

---

Building an API Server

A Go web server can also act as a REST API.

For example:

GET /api/users
POST /api/users
GET /api/products
POST /api/login

Response:

{
  "success": true,
  "data": []
}

This makes Go useful for mobile app backends and frontend applications.

---

Web Server vs REST API

A web server is a broader concept.

It can return:

HTML
CSS
JavaScript
JSON
Images
Files

A REST API usually focuses primarily on structured data such as JSON.

For example:

Web Server:
GET /about
→ HTML page

REST API:
GET /api/users
→ JSON response

A single Go application can do both.

---

Handling Concurrent Requests

Go’s HTTP server handles requests concurrently.

Each incoming request can be processed independently.

Conceptually:

Request 1 ──> Handler
Request 2 ──> Handler
Request 3 ──> Handler

This concurrency model is one of the reasons Go is popular for network servers.

However, you must be careful when handlers access shared mutable data.

---

Avoid Data Races

Consider:

var counter int

Then multiple handlers modify:

counter++

Concurrent requests can cause a data race.

Use appropriate synchronization such as:

sync.Mutex

or move shared state into a properly managed database or service.

You can detect races with:

go test -race ./...

---

HTTPS

Production websites should use HTTPS.

HTTPS protects data between clients and the server.

Go supports HTTPS directly:

http.ListenAndServeTLS(
    ":443",
    "cert.pem",
    "key.pem",
    mux,
)

In many deployments, HTTPS is terminated by a reverse proxy or cloud platform.

---

Reverse Proxy

A production architecture may look like:

Internet
   |
   v
Nginx / Load Balancer
   |
   v
Go Web Server

The reverse proxy can manage:

HTTPS
Load balancing
Compression
Caching
Domain routing

---

Dockerizing the Server

You can package a Go web server using Docker.

Example:

FROM golang:latest AS builder

WORKDIR /app

COPY go.mod go.sum ./

RUN go mod download

COPY . .

RUN go build -o server .

FROM alpine:latest

WORKDIR /app

COPY --from=builder /app/server .

EXPOSE 8080

CMD ["./server"]

Build:

docker build -t go-web-server .

Run:

docker run -p 8080:8080 go-web-server

---

Deploying a Go Web Server

Go servers can be deployed on many platforms.

Common options include:

AWS
Google Cloud
Microsoft Azure
DigitalOcean
Render
Railway
Fly.io
VPS
Docker
Kubernetes

Go’s compiled binaries make deployment relatively straightforward.

---

Production Best Practices

Before deploying a Go web server, consider:

• configure timeouts
• use HTTPS
• validate all input
• avoid exposing internal errors
• add structured logging
• keep secrets in environment variables
• use graceful shutdown
• configure CORS carefully
• use authentication where required
• add rate limiting where appropriate
• monitor server health
• write tests
• use database connection pooling
• keep dependencies updated

---

Common Beginner Mistakes

Ignoring ListenAndServe Errors

Avoid:

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

without checking errors.

Better:

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

if err != nil {
    log.Fatal(err)
}

---

Putting Everything in main.go

This is okay for learning, but large projects should separate:

Handlers
Services
Repositories
Middleware
Models
Configuration

---

Forgetting Content-Type

If returning JSON, set:

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

For HTML:

w.Header().Set(
    "Content-Type",
    "text/html; charset=utf-8",
)

---

Hardcoding Secrets

Never put production passwords or API keys directly into your source code.

Use environment variables or a proper secret-management solution.

---

No Server Timeouts

A production server should usually define timeout values.

This reduces the risk of connections staying open indefinitely.

---

Complete Beginner Web Server Example

Here is a clean example combining several concepts:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
    "time"
)

type APIResponse struct {
    Message string `json:"message"`
}

func homeHandler(
    w http.ResponseWriter,
    r *http.Request,
) {
    w.Header().Set(
        "Content-Type",
        "text/html; charset=utf-8",
    )

    w.Write(
        []byte(
            "<h1>Welcome to Go Web Server</h1>",
        ),
    )
}

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

    response :=
        APIResponse{
            Message:
                "Go API is working",
        }

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

func loggingMiddleware(
    next http.Handler,
) http.Handler {
    return http.HandlerFunc(
        func(
            w http.ResponseWriter,
            r *http.Request,
        ) {
            start :=
                time.Now()

            next.ServeHTTP(
                w,
                r,
            )

            log.Printf(
                "%s %s %s",
                r.Method,
                r.URL.Path,
                time.Since(start),
            )
        },
    )
}

func main() {
    port :=
        os.Getenv("PORT")

    if port == "" {
        port = "8080"
    }

    mux :=
        http.NewServeMux()

    mux.HandleFunc(
        "/",
        homeHandler,
    )

    mux.HandleFunc(
        "/api",
        apiHandler,
    )

    server :=
        &http.Server{
            Addr:
                ":" + port,

            Handler:
                loggingMiddleware(
                    mux,
                ),

            ReadTimeout:
                10 * time.Second,

            WriteTimeout:
                10 * time.Second,

            IdleTimeout:
                60 * time.Second,
        }

    log.Printf(
        "Server running on http://localhost:%s",
        port,
    )

    err :=
        server.ListenAndServe()

    if err != nil &&
        err != http.ErrServerClosed {

        log.Fatal(err)
    }
}

Run:

go run main.go

Open:

http://localhost:8080

For JSON:

http://localhost:8080/api

Response:

{
  "message": "Go API is working"
}

---

What Should You Learn Next?

Once you can build a basic Go web server, continue learning:

Routing
REST APIs
JSON
Middleware
PostgreSQL
Authentication
JWT
Cookies
Sessions
Templates
WebSockets
Testing
Docker
Deployment
Caching
Redis
Security

These topics will help you move from a beginner server to production backend development.

---

Frequently Asked Questions

Can Go create a web server?

Yes.

Go includes the net/http package, which provides everything needed to create HTTP web servers.

Do I need a framework?

No.

You can build complete web servers using the Go standard library.

Frameworks can be added later for convenience.

What port should a Go server use?

For local development, ports such as:

8080
3000
8000

are common.

Production ports depend on your infrastructure.

How do I start a server?

The simplest approach is:

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

How do I create routes?

Use:

http.HandleFunc(
    "/about",
    aboutHandler,
)

or create your own ServeMux.

Can a Go server return JSON?

Yes.

Use:

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

Can Go serve HTML?

Yes.

You can send HTML directly, serve HTML files, or use the html/template package.

Can Go serve CSS and JavaScript?

Yes.

Use:

http.FileServer()

to serve static files.

Can Go handle many requests?

Yes.

Go’s HTTP server is designed for concurrent request handling, and Go’s concurrency model makes it well suited for network applications.

Is Go good for production web servers?

Yes.

Go is widely used for APIs, web servers, microservices, cloud services, networking systems, and production backend applications.

Should I learn net/http before Gin or Fiber?

Yes, especially as a beginner.

Understanding net/http teaches you how Go’s HTTP system works underneath frameworks.

---

Conclusion

Building a web server in Go is simple because the language includes strong HTTP support directly in its standard library.

A minimal server requires only:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc(
        "/",
        func(
            w http.ResponseWriter,
            r *http.Request,
        ) {
            fmt.Fprintln(
                w,
                "Hello from Go",
            )
        },
    )

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

From this simple foundation, you can add:

Multiple routes
HTML pages
JSON APIs
Static files
Templates
Middleware
Databases
Authentication
Logging
Timeouts
Graceful shutdown
Testing
Docker
Deployment

The best way to learn is to first build a small server using only net/http, then gradually turn it into a complete backend application.

Once you understand handlers, routing, requests, responses, middleware, and server configuration, you will have a strong foundation for building REST APIs, websites, mobile app backends, microservices, and production web services with Go.