Building a Simple URL Shortener in Go

I built this project to better understand how web servers work in Go while keeping things clean, simple, and practical. A URL shortener is a great learning project because it combines HTTP handling, hashing, and concurrency in one place.

In this post, I’ll walk through how my Go-based URL shortener works and explain the key ideas behind it.

What This Project Does

At a high level, my URL shortener:

• Accepts a long URL
• Generates a short, unique key
• Stores the mapping in memory
• Redirects users to the original URL

Available Endpoints

I intentionally used only Go’s standard library to keep the project lightweight and beginner-friendly.

Core Data Structure

At the heart of the application is a simple struct:

1
type URLShortener struct {
2
    urls map[string]string
3
    mu   sync.RWMutex
4
}

Why this design?

• urls stores the mapping between short keys and original URLs
• sync.RWMutex ensures thread-safe access when multiple users hit the server at the same time

Note: Since this data is stored in memory, everything resets when the server restarts. This is acceptable for a learning project.

Generating Short URLs

To generate short keys, I used SHA-256 hashing combined with Base64 encoding:

1
func generateShortKey(originalURL string) string {
2
    algorithm := sha256.New()
3
    algorithm.Write([]byte(originalURL))
4
    hashBytes := algorithm.Sum(nil)
5

6
    encoded := base64.URLEncoding.EncodeToString(hashBytes)
7
    return encoded[:8]
8
}

Why this approach works

• SHA-256 ensures the same URL always generates the same hash
• Base64 encoding keeps the output URL-safe
• Trimming to 8 characters keeps links short and readable

This approach isn’t ideal for large-scale systems due to potential collisions, but it works well for a demo project.

Creating a Short URL

The /shorten endpoint handles URL creation:

1
func makeShortURL(w http.ResponseWriter, req *http.Request) {
2
    if req.Method != http.MethodPost {
3
        http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
4
        return
5
    }
6

7
    originalURL := req.FormValue("url")
8
    if originalURL == "" {
9
        http.Error(w, "URL parameter is missing", http.StatusBadRequest)
10
        return
11
    }
12

13
    shortKey := generateShortKey(originalURL)
14

15
    shortener.mu.Lock()
16
    shortener.urls[shortKey] = originalURL
17
    shortener.mu.Unlock()
18

19
    constructURL := fmt.Sprintf("http://localhost:8090/%s", shortKey)
20
    fmt.Fprintf(w, "Shortened URL: %s\n", constructURL)
21
}

What happens here?

1. The request method is validated
2. The URL is extracted from the form data
3. A short key is generated
4. The mapping is stored safely using a mutex
5. The shortened URL is returned to the client

Redirecting Users

When someone visits a short URL, the root handler takes over:

1
func handleRedirect(w http.ResponseWriter, req *http.Request) {
2
    shortKey := strings.TrimPrefix(req.URL.Path, "/")
3

4
    shortener.mu.RLock()
5
    originalURL, ok := shortener.urls[shortKey]
6
    shortener.mu.RUnlock()
7

8
    if !ok {
9
        http.Error(w, "Short URL not found", http.StatusNotFound)
10
        return
11
    }
12

13
    http.Redirect(w, req, originalURL, http.StatusFound)
14
}

If the short key exists, the server responds with a 302 Found redirect, sending the user to the original URL.

Running the Server

Everything is wired together in main:

1
func main() {
2
    http.HandleFunc("/shorten", makeShortURL)
3
    http.HandleFunc("/", handleRedirect)
4

5
    fmt.Println("Server starting on port :8090...")
6
    http.ListenAndServe(":8090", nil)
7
}

Once started, the server listens on port 8090.

How To Test It

# Start the server
go run main.go

# Create a short URL
curl -X POST -d "url=https://example.com" http://localhost:8090/shorten

Opening the returned short URL in a browser redirects to the original site.

Possible Improvements

If I continue developing this project, I would consider:

• Persisting URLs using a database
• Handling hash collisions more robustly
• Adding expiration times for shortened URLs
• Validating URL formats
• Returning JSON instead of plain text responses

Final Thoughts

This project helped me better understand how Go handles HTTP servers, concurrency, and cryptographic hashing using only the standard library.

For anyone learning Go, projects like this are an excellent way to build practical experience and confidence.