Let’s kick off our Learning by Doing with Golang series by building a simple ToDo application. This app will serve as our first hands-on project to understand the fundamentals of Go by applying them in a real-world context.
🧠 Pre-requisites
Before jumping into this project, we expect you to have a basic understanding of Golang, including:
Basic syntax and structure
Variables and data types
Arithmetic and logical operators
Conditional statements (if, switch)
Loops (for)
Functions and how to define/use them
If you're just starting out with Go and haven't covered these fundamentals yet, we recommend learning them first. You can find great beginner-friendly resources here , and once you're comfortable, come back and join us on this hands-on journey.
Note: We’re intentionally keeping this app simple to focus on learning. As we progress, you might notice some discrepancies or missing best practices—that’s by design. We’ll note these issues along the way and revisit them after we've developed a deeper understanding of Go. For now, the goal is to get started without getting overwhelmed.
📝 What Are We Building?
We’re developing a basic ToDo list application that allows users to manage their tasks efficiently. The app will support the standard set of CRUD operations—Create, Read, Update, and Delete ToDos.
What is ToDo app ?
A ToDo app is a simple task management application that helps users keep track of things they need to do.
🔗 Note: We are not building a frontend or UI for this app. All interactions will happen through RESTful APIs. This will help us focus purely on backend development using Golang, and better understand how to build, structure, and manage APIs effectively
🧩 Design and Requirements
Before diving into the implementation, let’s understand the design requirements of our ToDo application and the reasoning behind each decision.
🔍 What Do We Need?
A place to store ToDo data
A Way to Access the content Database
A Way for Users to Interact with the App
Let’s see how we are planning that
🗃️ 1. Data Storage — Using MySQL
The first thing our app needs is a place to store the ToDo items. For this, we’ll use a database, as it's the most common and reliable way to store structured data in applications. Specifically, we’ll use a MySQL database
💡 Why SQL?
There are two main types of databases:
We're choosing SQL (MySQL) for the following reasons:
It’s faster and more efficient for structured data.
Our data is simple and relational (each ToDo has fields like title, description, status).
We don’t require the flexibility of a document-based (NoSQL) structure for this use case.
It fits the purpose of a basic CRUD app with limited and predictable data.
🔌 2. Database Access — Using Golang’s Standard Library
To interact with our database and access the stored data, we need a way to connect to the database and execute SQL queries.
We’ll use one of Go’s standard libraries together with a MySQL driver. This setup allows us to:
Open and manage database connections
Execute SQL commands (INSERT, SELECT, UPDATE, DELETE)
Handle errors and manage resources efficiently
We'll explore the exact setup and usage of these libraries in the later section.
🌐 3. Application Access — Through HTTP Endpoints
Now, as an end-user, how do we interact with our application?
We’ll expose a set of HTTP endpoints that clients (like browsers, Postman, or frontend apps) can call using URLs.
For example:
GET https://<your-app>/todos → Get all ToDos
POST https://<your-app>/todos → Create a new ToDo
GET https://<your-app>/todos/{id} → Get a specific ToDo
PUT https://<your-app>/todos/{id} → Update a ToDo
DELETE https://<your-app>/todos/{id} → Delete a ToDo
These endpoints will act as entry points to different operations within our app. Internally, each endpoint will trigger logic that interacts with the database and returns appropriate responses.
🧠 Wrapping Up
Now, we have a high-level understanding of what we need to build our ToDo app—and more importantly, why we need each component.
Don’t worry if everything doesn’t fully click yet. As we build more apps and go deeper into each concept, things will start to make sense. The key is to keep going.
🚀 What’s Next?
In the next article, we’ll focus entirely on the Database Layer of our application. Here's what we’ll cover:
How to set up a MySQL database locally
How to connect to the database using Golang
Different approaches to database interaction in Go—and why we’re choosing a specific one
Step-by-step guide to implement the database layer in our ToDo app
We’ll apply everything we learn directly into our project, laying a strong foundation for how our app stores and retrieves data.
