Joel Teodoro Gómez JoelTeoGom

Go · Distributed Systems · Kubernetes · Database Internals

_{Backend Engineer · Catalonia, Spain 🇪🇸}

`$ uname -a`

joel-teodoro 24.0-go #1 SMP PREEMPT backend distributed-systems x86_64 GNU/Linux

I build booking platforms in Go: hotels and buses, real traffic, real money. What I enjoy is opening the layers underneath. Right now that means Kubernetes (CKA on the way) and database internals. This GitHub is where I rebuild things from scratch until they stop being magic, and runtimerants.dev is where I write down what broke along the way.

📚 software-engineering-guide The articles, blogs and books that shaped how I think about software, each with what I took from it.

`$ cat /proc/joel/status`

Name:      joel-teodoro
State:     R (running)            # backend in production, every day
Lang:      go                     # everything I ship
Layer:     application → kernel   # currently descending
Focus:     linux · networking · kubernetes · storage engines
Signals:   SIGTERM ignored        # graceful shutdown, obviously

`$ lsmod | grep focus`

Module              State       Notes
linux_internals     loaded      namespaces, cgroups: a container is just a process with opinions
netfilter           loaded      iptables, conntrack, DNAT/SNAT: how a ClusterIP actually gets routed
kubernetes          loaded      control plane, reconciliation loops, CNI, kube-proxy · CKA in progress
storage_engines     loading     pages, B+ trees vs LSM, WAL, MVCC: everything ends up on disk

`$ kubectl get pods -n lab`

Building the things I use, from scratch, until they stop being magic.

NAME                      READY   STATUS    AGE
kubernetes-from-scratch   1/1     Running   building
pdfbox-aws                1/1     Running   shipped
my-http-server            1/1     Running   shipped
go-key-affinity-lb        1/1     Running   shipped
go-sharded-ws-hub         1/1     Running   shipped

kubernetes-from-scratch

A toy Kubernetes, written by hand

A control plane, node agents and an L4 load balancer in front, talking over a protocol of their own. The agent does what kubelet and kube-proxy do: pod lifecycle, network namespaces, veth pairs, a node bridge, and KUBE-* iptables chains that DNAT a service address to a real pod. Nothing wraps an existing tool.

pdfbox-aws

File bytes never touch the backend

Serverless multi-tenant storage: Go on Lambda, DynamoDB for metadata, uploads straight to S3 with presigned URLs. S3 events into SQS with a DLQ, an EventBridge-scheduled sweeper over a sparse GSI. All Terraform.

my-http-server

HTTP, parsed by hand

Request parsing, routing and responses written from scratch over raw TCP. The fastest way I know to stop treating net/http as magic.

go-key-affinity-lb

1000 concurrent requests, 4 backend calls

Key-affinity routing plus singleflight on each node. Neither works alone: affinity puts every request for a key on the same node, singleflight collapses them there.

go-sharded-ws-hub

Fan-out that survives slow clients

Sharded in-memory hub, one write pump per connection, non-blocking send. A client that can't keep up gets dropped. One slow consumer should never stall the broadcast.

`$ cat stack.yml`

core:
  language:   go
  apis:       [graphql, grpc, rest, websockets]
  data:       [mysql, postgresql, redis, elasticsearch]
  messaging:  [pub/sub, rabbitmq, kafka]

infrastructure:
  orchestration: [kubernetes, docker]
  cloud:         [gcp, cloud-run, aws]
  aws:           [lambda, api-gateway, dynamodb, s3, sqs, eventbridge, iam]
  iac:           [terraform]
  ci_cd:         [gitlab-ci, github-actions]
  linux:         [namespaces, cgroups, netfilter/iptables]

architecture:
  - hexagonal / ports & adapters
  - domain-driven design
  - event-driven services
  - caching, and the harder half: invalidation

also_shipped:
  - java / spring-boot          # two years of it, same team. I wrote a post about it
  - python, c                   # tooling and systems coursework

`$ ls -la ~/archive`

Earlier builds: Go concurrency and system design, one failure mode per repo

Repo	What it does
`go-redis-token-bucket`	One rate limit across N nodes, enforced by an atomic Lua script
`go-hash-ring`	Consistent hashing with virtual nodes, every number measured
`go-priority-scheduler`	Min-heap ordering, `sync.Cond` parking, no idle spinning
`CrispLite`	Chat end to end: WebSockets, Redis Pub/Sub, Postgres, hexagonal
`DDD-Ecommerce`	Bounded contexts and aggregates that enforce their own invariants
`go-errgroup-example`	Parallel fetch, bounded concurrency, first error wins
`go-circuit-breaker-example`	Full `CLOSED → OPEN → HALF-OPEN` cycle against a failing downstream
`go-fanout-race`	Fan out N requests, keep the fastest, cancel the rest
`SingleFlight-Golang`	Collapsing duplicate in-flight calls so a cache miss isn't a stampede
`Snowflake-generator-service`	64-bit time-ordered IDs, no coordination
`Data-structures`	The usual suspects, from scratch, with generics

`$ cat ~/reading/now`

+ Database Internals            Petrov       in progress
+ Designing Data-Intensive Apps Kleppmann    halfway, no rush
+ Concurrency in Go             Cox-Buday    read it twice

The full list lives in the guide linked above.

`$ tail -n 5 ~/writing/log`

Deep dives from runtimerants.dev, with the benchmarks and the source, because "it's faster" isn't an argument:

Write-Ahead Log Internals: what actually happens on INSERT, and how it ends up as CDC
DB Indexes & Transactions: B+ trees and row locks are the same story told twice
singleflight Internals: one hot key expires, N requests hit the DB
The context Package: cancellation across a concurrent call graph
Go vs Spring Boot: two years with both, same team, actual numbers

`$ dig +short joel.contact`

{
  "blog":     "https://runtimerants.dev",
  "linkedin": "linkedin.com/in/joel-teodoro-gomez",
  "email":    "joel.teodoro.software@gmail.com",
  "status":   "open to backend / platform / distributed systems roles, remote or Barcelona"
}

// TODO: write better commit messages

Navigation Menu