From Figma to Functions
Two years ago, I was purely a UX designer. I lived in Figma, spoke in user journeys, and thought "backend" was just where data lived. Then I joined Google and everything changed.
My first week, I attended a Go code review meeting. I understood maybe 10% of what was discussed, but something clicked. The simplicity, the clarity, the way problems were broken down – it felt like good design thinking, but in code.
Why Go Felt Different
I'd tried learning JavaScript and Python before. Both felt overwhelming – too many ways to do the same thing, too many frameworks to choose from. Go was different. It reminded me of the design principle: "good design is as little design as possible."
The Designer Brain Loves:
- Clear conventions: One obvious way to do things
- Readable code: You can understand it just by reading
- Fast feedback: Compilation errors are immediately clear
- Simple deployment: One binary, no dependencies
My First Real Go Project
Our team needed a simple API to serve user preference data to our frontend. The backend team was swamped, so I volunteered to prototype it. "How hard could it be?"
Famous last words, right? But surprisingly, it wasn't that hard.
func getUserPreferences(w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user")
if userID == "" {
http.Error(w, "user parameter required", http.StatusBadRequest)
return
}
// Fetch from database
prefs, err := db.GetPreferences(userID)
if err != nil {
http.Error(w, "unable to fetch preferences", http.StatusInternalServerError)
return
}
// Return JSON
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(prefs)
}What I Loved About This:
- The function name tells you exactly what it does
- Error handling is explicit and clear
- No magic – you can follow the logic step by step
- It works the same way every time
The Design Thinking Connection
Learning Go taught me that good code and good design share the same principles:
"Clarity over cleverness. Simplicity over complexity. Consistency over novelty. These aren't just design principles – they're life principles."
Challenges (And How I Overcame Them)
Pointers and Memory Management
Coming from design tools, the concept of memory management was foreign. But Go's garbage collector handles most of this automatically. When I did need pointers, I thought of them like "references" to shared design assets.
Goroutines and Concurrency
This was actually easier to understand than I expected. Goroutines are like having multiple design processes running at the same time – each working on their own task, occasionally sharing results.
Testing Philosophy
Go's testing approach clicked immediately. It's like usability testing for code – you write scenarios to make sure your functions behave as expected.
func TestGetUserPreferences(t *testing.T) {
// Test with valid user
req := httptest.NewRequest("GET", "/prefs?user=123", nil)
w := httptest.NewRecorder()
getUserPreferences(w, req)
if w.Code != http.StatusOK {
t.Errorf("Expected status 200, got %d", w.Code)
}
}How Learning Go Changed My Design Work
Better API Design
Understanding how APIs work made me a better UX designer. I now design interfaces knowing how the data flows behind them. My designs are more technically feasible because I understand the constraints.
Performance Awareness
Learning about Go's performance characteristics made me more conscious of how my design decisions affect real users. Big images, complex animations, unnecessary API calls – I now think about the cost of every design element.
System Thinking
Go forced me to think in systems – how different parts connect, how data flows, how errors propagate. This made me better at designing cohesive user experiences across multiple touchpoints.
To Other Designers Considering Code
Start With Why
Don't learn to code just because you think you should. Find a real problem you want to solve. For me, it was understanding how the products I designed actually worked.
Choose Your Language Wisely
Go might not be the "best" first language for everyone, but it was perfect for me. The simplicity reduced cognitive load, letting me focus on learning programming concepts rather than language quirks.
Embrace Beginner's Mind
Coming from design, I had strong opinions about "good" and "bad." Programming taught me to question assumptions and stay curious. Sometimes the "ugly" solution is the right one.
The Kawaii Coder Journey
Learning Go didn't make me a programmer who designs. It made me a designer who codes. I still think like a UXer – focusing on user needs, clear communication, and delightful experiences. But now I can prototype my ideas end-to-end.
The best part? My anime figurines look perfectly at home next to my programming books. Some of my best debugging sessions happen while wearing kawaii pajamas and drinking way too much coffee.
What's Next
I'm not trying to become a full-stack engineer overnight. But having programming skills has made me infinitely more effective as a UX designer. I can prototype complex interactions, understand technical constraints, and speak the same language as my developer teammates.
Most importantly, learning Go reminded me why I love technology: it's a tool for solving human problems. Whether I'm designing an interface or writing a function, the goal is the same – make someone's life a little bit better.
And if I can do it while embracing my kawaii aesthetic and Mexican heritage, even better. Technology doesn't have to be boring just because it's serious.