One of my self-directed exercises in learning Go: building a REST weather API that pulls data from an external provider. Weather providers typically enforce request-per-minute limits — so the challenge wasn't just "fetch the data," but "fetch it without hitting the rate limit while staying responsive."

I structured the system with layered clean architecture (domain → repository → client → service → handler) so business logic wouldn't get tangled up with HTTP client or caching details. The service layer checks Redis/Valkey first before calling the external provider — identical requests within a given time window are served straight from cache.

• Response time for previously requested data dropped significantly since no round-trip to the provider was needed
• The layered structure makes it easy to add other weather providers without touching the handler
• Became the foundation for my understanding of dependency injection & interfaces in Go

Backend for Atomize Planner — a productivity app that helps users break large tasks into small, manageable steps (AI-assisted), run focus sessions, and track weekly productivity history. Built as a team collaboration project, not a solo effort.

I contributed to several parts: drafting api-contract.yaml together with the team as a shared reference before implementation, building the models & data structure in Laravel, implementing the profile endpoints (get, update, avatar upload, change password) and task-related endpoints (task CRUD along with their steps), and taking part in code review for other team members' contributions.

• Defining the API contract upfront let frontend & backend work in parallel without blocking each other
• Got hands-on with a team Git workflow: branching, PR reviews, and keeping code aligned with the agreed-upon endpoints
• My first experience sharing backend responsibilities across a team instead of building everything alone

Before moving into more complex web architecture, I deliberately trained my Go fundamentals through a series of small CLI projects — my way of getting comfortable with structs, interfaces, and Go-style error handling without any framework distractions.

Built three separate tools: a task tracker, a GitHub activity tracker, and an expense tracker — each reading flags from the CLI and persisting state to a JSON file. I applied generics to the storage functions so they could be reused across all three tools.

• This understanding of generics & interfaces carried directly into building a Go blog project with clean architecture
• Served as a safe "sandbox" to experiment before taking on bigger projects