DEV Community: Austine Zeze Muyonga

Building a Backend With Go and Neon PostgreSQL: Lessons From My E-Commerce Project

Austine Zeze Muyonga — Wed, 30 Sep 2026 19:35:38 +0000

One of my goals as a developer is to move beyond building static websites and learn how to create applications that store, retrieve, and manage real data.

That goal has influenced my work on Austine Kicks, a sneaker e-commerce project I am developing using HTML, CSS, JavaScript, Go, and Neon PostgreSQL.

In this post, I want to share some of the lessons I have encountered while exploring backend development and database integration.

Why I Chose Go for the Backend

I have been learning Go at Zone01 Kisumu, and I wanted to apply what I was learning to a practical project.

Go provides a way to build HTTP servers, handle requests, define application logic, and communicate with databases.

For my project, I started organizing the backend into different responsibilities rather than placing everything in a single file.

My structure includes areas for:

Server startup.
Database connection and schema.
HTTP handlers.
Data models.
Middleware.
Routes and application logic.

Separating these responsibilities makes the code easier to understand and maintain as the project grows.

Working With Neon PostgreSQL

For the database, I chose Neon, a hosted PostgreSQL service.

The application needs to manage product information such as names, brands, categories, prices, available sizes, stock quantities, descriptions, and product images.

I also started planning the database structure for orders and order items.

A simplified product table might look like this:

CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name VARCHAR(150) NOT NULL,
    brand VARCHAR(100),
    category VARCHAR(100),
    price NUMERIC(10, 2) NOT NULL,
    stock INTEGER NOT NULL DEFAULT 0,
    description TEXT,
    image TEXT,
    featured BOOLEAN DEFAULT FALSE
);

This structure provides a starting point for storing sneaker information in a consistent format.

Connecting the Database to Go

The backend needs a database connection before it can retrieve or save products.

I configured the application to read the database connection string from an environment variable called DATABASE_URL.

This is important because database credentials should not be hardcoded into the source code or committed to a public repository.

I also worked on applying the database schema and seeding initial products to make development and testing easier.

Understanding the Frontend-Backend Connection

One challenge I encountered was ensuring that the frontend requested data from the correct API endpoint.

For example, if the backend exposes products through /api/products, the frontend must request that same path.

If the frontend requests /data/products instead, the server may return a 404 error even when the database is connected successfully.

This taught me an important lesson: a working database does not automatically mean that the entire application is working.

The database, backend routes, API responses, and frontend JavaScript must all work together.

What I Have Learned

Working on Austine Kicks has helped me understand that backend development involves more than writing database queries.

I need to think about data models, API design, configuration, error handling, security, and how different components communicate.

I am still improving the project, but every problem I solve gives me a clearer understanding of how full-stack applications are built.

My next steps include strengthening validation, improving error handling, testing API endpoints, and making the application easier to deploy.

For developers who have built Go applications with PostgreSQL, what practices helped you organize your backend and database code?

Go #PostgreSQL #Neon #BackendDevelopment #WebDev

My Journey Into Software Development: From HTML and CSS to Building Real Projects With Go

Austine Zeze Muyonga — Tue, 29 Sep 2026 17:37:11 +0000

When I first started learning software development, my experience was mainly with HTML, CSS, and a little JavaScript. I understood how to create web pages and style them, but I wanted to go beyond the frontend. I wanted to understand how applications work behind the scenes, how data is stored, and how different parts of a system communicate.

That curiosity led me to Zone01 Kisumu, where my learning journey became more practical and challenging.

Discovering Go as My First Serious Programming Language

Go became the first programming language I started learning seriously. Coming from HTML and CSS, I quickly realized that programming requires a different way of thinking.

Instead of focusing only on how a page looks, I had to learn how to break down problems into smaller steps, work with variables and functions, understand control flow, and write logic that produces the expected output.

Some of the concepts I have been working on include:

Variables, data types, and operators.
Functions and parameters.
Loops and conditional statements.
Strings and string manipulation.
Arrays, slices, and maps.
Error handling and debugging.
Git and collaborative development.

Projects and exercises such as WordAnatomy, RepeatAlpha, HashCode, and Camel-to-Snake Case have helped me practice these concepts.

Learning Through Challenges

One thing I have learned is that understanding a concept when someone explains it is different from applying it independently.

Sometimes a problem looks simple until you start writing the code. You might understand the expected output but struggle to determine the steps needed to achieve it.

I have learned to approach these challenges by breaking problems down, testing smaller pieces of logic, reading error messages carefully, and trying different solutions.

The process can be frustrating, but every challenge I solve gives me more confidence.

Moving From Exercises to Real Projects

Beyond programming exercises, I have also been exploring practical projects, including Austine Kicks, an e-commerce platform for sneakers, and DumpTrade, a waste-exchange platform developed during a GreenTech hackathon.

These projects have helped me understand that building software involves much more than writing code. You also need to think about databases, APIs, user experience, deployment, teamwork, and maintenance.

What I Am Learning Along the Way

I am still learning, and I do not consider myself an expert. However, I now understand that becoming a developer is a continuous process of learning, experimenting, making mistakes, and improving.

My goal is to become a full-stack developer who builds useful solutions to real community problems.

I am documenting this journey because I believe that sharing what we learn can help other beginners who are on a similar path.

If you are also starting your software development journey, what programming language or project are you currently working on?

Let's learn and grow together.

DEVCommunity #100DaysOfCode #Go #WebDev #Beginners

Learning Go as a beginner developer

Austine Zeze Muyonga — Tue, 02 Jun 2026 10:31:43 +0000

My journey with Go began when I decided to move beyond frontend technologies. At the time, I only had experience with HTML, CSS, and a little JavaScript, so Go became the first programming language I committed to learning in depth. Starting out was both exciting and challenging because many of the concepts were completely new to me. However, I quickly found Go interesting due to its simple syntax and structured approach to programming. Every new topic I learn, from functions and loops to packages and error handling, helps me better understand how software is built behind the scenes.

Although I have not fully mastered Go yet, I am making steady progress and enjoying the learning process. My goal is to gain a solid understanding of the language within the next two months and become confident enough to build backend projects with it. I see Go as an important step in my growth as a software developer, and I am excited about the opportunities it opens up for creating scalable and efficient applications. As I continue learning and practicing, I look forward to turning my knowledge into real-world projects and sharing more of my experiences with the developer community.