I used Golang to build a image processing server that transforms images using background goroutines

Watch the Youtube demo video above to see it in action.
I wanted to explore how far I could push Go's concurrency model, so I built a full picture processing server from the ground up in Golang. The idea was simple to describe and genuinely satisfying to build. Upload a picture, choose an effect, and watch it get transformed in the background while the rest of the application keeps running without pause.
At the center of the project are three goroutines, each one acting as an independent processor pulling jobs from a shared queue. When a picture is uploaded, it does not get processed immediately inside the request. Instead, it gets validated, saved, and handed off to a job queue. From there, whichever goroutine is free picks it up, works through the transformation, and updates that job's status in real time, moving it from waiting to being processed to finished.
This is the same pattern that powers real production systems that need to handle work without blocking the user. Watching three goroutines pull from one queue, process images completely independently, and never step on each other's work was one of the most rewarding parts of building this.
The server itself is a REST API with Swagger documentation, giving anyone the ability to test every endpoint directly in the browser. I built four image transformations from scratch using Go's image libraries: grayscale, blur, resize, and pixelate. Every single upload gets a unique job ID, so its status can be tracked all the way through the pipeline, and if something fails, the system records exactly why rather than failing silently.
On the frontend, I built an interface that lets you upload a picture, pick an effect, and compare the original against the processed result with a live slider, all connected to the same backend through a clean REST API with proper handling for cross origin requests.
Building this taught me a lot about how concurrency actually behaves in production style systems, not just in theory. Designing the queue, coordinating multiple goroutines safely, and tracking state across concurrent processes gave me a much deeper appreciation for what Go was built to do well.
This project represents everything I love about backend engineering. Taking a real problem, breaking it into clean independent pieces, and watching it all work together seamlessly. I am proud of what I built here, and I am excited to keep pushing further into Go and concurrent systems design.