# From CLI to Docker: What Three Go Projects Taught Me

When I started the ascii-art project, I thought I was just going to print text in different ASCII fonts.

A few weeks later, I had built a web server, learned the basics of HTTP, worked with HTML templates and CSS, handled user input, and packaged the entire application with Docker.

Looking back, ascii-art, ascii-art-web, and ascii-art-web-dockerize were more than coding exercises—they showed me how software evolves from a simple command-line tool into a deployable web application.

1. Building ascii-art

The first project introduced me to much more than string manipulation. I learned how to:

Parse files and process user input.
Organize code into reusable functions and packages.
Handle errors and edge cases.
Follow the flow of a Go application instead of putting everything inside main().

One lesson that stood out was understanding program flow:

main()
↓
ParseInput()
↓
LoadBanner()
↓
GenerateASCII()
↓
PrintOutput()

Once I understood how functions work together, reading larger Go projects became much easier.

1. Building ascii-art-web

Turning the terminal application into a web application introduced me to backend development.

Along the way I learned:

The difference between GET and POST requests.
How HTTP handlers process requests and return responses.
How to render HTML using Go templates.
Basic CSS to improve the user experience.
How to validate input and return meaningful error pages.

For the first time, I saw how a browser communicates with a Go server and how each request flows through the application.

1. Dockerizing the Application

The final project introduced me to Docker and deployment.

I learned how to:

Package an application into a container.
Write Dockerfiles.
Use multi-stage builds to create smaller production images.
Take advantage of Docker layer caching for faster rebuilds.

It also helped me understand why containers are so widely used: they make applications portable and consistent across environments.

Beyond the Code

These projects changed the way I approach software development.

I became more confident in:

Debugging problems instead of guessing.
Reading documentation.
Structuring Go projects.
Breaking large problems into smaller tasks.
Using Git throughout development.

Most importantly, I realized that software is built step by step. A command-line application can grow into a web application, and that same application can be prepared for deployment with Docker.

Final Thoughts

What started as a project to print ASCII characters became one of the most valuable learning experiences in my Go journey.

These three projects strengthened my understanding of Go, web development, and containerization while showing me how real-world applications evolve over time.

I'm looking forward to applying these lessons as I continue building larger, production-grade applications.