Golang

Picked up Go for the simplicity and never really left. Goroutines and channels make concurrency feel built into the language rather than bolted on, which matters when you're wiring up gRPC services or chasing a caching bug at 2am. It's my default for backend work now.

AWS

Gives you enough low-level control to build exactly the architecture you want, which is both a blessing and a good way to shoot yourself in the foot. Working on EC2 infrastructure at AWS gave me a much better sense of what's actually happening underneath the abstractions most people never look past.

GCP

Ran production workloads on GCP daily during my time at Nile, and it's hard not to appreciate how much friendlier the developer experience is compared to some of the alternatives. IAM and networking still take some getting used to, but the tooling feels like it was built by people who actually write code.

Python

It remains my go-to for quick scripts, data wrangling, or automating something I don't want to do by hand twice. The syntax gets out of the way, which is exactly what you want from glue code. Enjoy FastAPI for CRUD like projects, but if I need something more concurrent friendly I reach for Go.

PostgreSQL

Five and a half years running PostgreSQL underneath Conservio taught me to actually read query plans instead of guessing at them. Proper indexing, window functions, and knowing when JSONB is the right escape hatch instead of the lazy one, it's the relational database I reach for by default now.

NodeJS

Almost every web project touches JS somewhere, whether that's the event loop handling I/O under the hood or another npm package pulled in to solve a problem I'd rather not solve myself. The ecosystem is massive and occasionally chaotic, but I write some JS every year regardless of what I'm mainly working in.

Docker

Hard to imagine working without containers at this point. I run most of my local dev environment through Docker so it mirrors production closely enough that 'works on my machine' stops being an excuse. Multi-stage builds and layer caching alone are worth the learning curve.

Kubernetes

Managed offerings like EKS and GKE hide most of the operational pain, but the underlying concepts, pods, deployments, service discovery, are worth understanding properly if you want to reason about failures instead of just restarting things. Still my orchestration tool of choice even when a provider is doing the heavy lifting.

React

Of all the JS frameworks I've used, still my favourite. The component model and hooks make state management click in a way class components never did for me.

React Native

My cross-platform tool of choice when native performance matters more than pure web reach. Bridging to native modules can get hairy, but sharing one codebase across iOS and Android still saves a lot of duplicated work.

Scala

Spent enough time in Scala to appreciate pattern matching and the JVM ecosystem, but functional programming never fully clicked for me the way it seems to for others. Comfortable enough to read and contribute to a codebase without slowing anyone down.

Distributed, gossip-coordinated token-bucket throttling middleware for Go HTTP services

An opinionated caching mechanism written in Go

A simple & small CLI tool to compress and decompress files using Golang

Simple & lightweight side menu drawer

Demystifying hashing, made simple and easy