Past

Welcome, I’m Patrik (or sometimes Sh4d1), and living in Paris!

I’m a long time Linux user (I use arch btw), that loves to build, and operates systems, especially distributed ones.

I was born in Stockholm in 1994, grew up in the french alps, graduated from Ensimag in early 2018, where among others things, I wrote a compiler in Java, a processor in VHDL, and a kernel in C.

I’m native in french, and fluent in english, while trying to keep my swedish up to the level.

Scaleway

Kubernetes

I then moved to Paris and joined Scaleway as a DevOps engineer on Kapsule, the managed Kubernetes solution in early 2019. The next 2.5 years were spent building from the ground up a Kubernetes distribution. I even made a webinar explaining how it all works under the hood (though a lot have changed since, for the best).

It taught me a lot about building systems, Kubernetes, containers, automation, configuration management, Golang, good practices, …

Let’s say I learned a lot these first years, and I loved it! It also started an unavoidable love/hate relationship with Kubernetes.

S3

The opportunity to join the object storage’s Site Reliability Engineer team presented itself in fall 2021, which I took. That brought me to spend the next 2.5 years building (in C) and running a globally distributed key/value database, Hive, meant to store the metadata of all S3 object, while contribuing to libfloat, a C raft implementation, by my colleague and friend Louis.

On top of that, I learned a lot about bare metal environment (PXE, networking, storage, …) with deployments of thousands of servers, across multiple regions, while also taking ownership and scaling the monitoring stack (elasticsearch, vector, prometheus/victoriametrics, grafana).

Present

amo

I left Scaleway in march 2024, to join a new adventure as SRE at amo.

The tables have turned, as I’m now on the other side of the spectrum, using a cloud provider, instead of building for one.

These 2.5 years have been spent building and running amo’s platform on GCP, with Kubernetes at its core and everything described as code with Pulumi. On top of Pulumi, I built a Go overlay: a set of typed, reusable components that wrap GCP, Kubernetes and our various operators behind a higher level API, so spinning up a new service or a stateful cluster is a few lines rather than a pile of boilerplate. The backend is mostly Rust services, talking to each other over gRPC and Protocol Buffers, with Restate handling durable execution for the trickier, long running workflows.

Being a data heavy product, a big part of the job is the stateful side of things. For storage, that means PostgreSQL (on both Cloud SQL and AlloyDB), as well as ScyllaDB and ClickHouse on Kubernetes, with Redis and Dragonfly for caching, and Typesense and Meilisearch for search. Data then flows around through Redpanda, often kicked off by change data capture straight from Postgres, built on Supabase’s etl Rust library to feed both Postgres to Redpanda and Postgres to Postgres pipelines, while NATS acts as an event bus between our APIs. Further down the pipe, custom Rust code lands it as Parquet in GCS, exposed as Iceberg tables that both Dataflow and Spark / Dataproc crunch on top of, and that we query through both BigQuery and ClickHouse.

I also took ownership of the observability stack. It’s built around Grafana, with Mimir for metrics, Quickwit for logs and traces, OpenTelemetry for instrumentation, and continuous profiling with Pyroscope and Parca. It’s also where I got to play with the newer bits of the ecosystem, like exemplars to jump from a metric straight to the trace behind it, and Prometheus native histograms for high resolution latencies without the cardinality explosion.

On the CI/CD front, our monorepo is built with Bazel. We started out on self hosted Linux and macOS runners, and the macOS ones, needed to build, sign and ship our iOS app, were the real pain: mac VMs on mac hosts with Tart (and a try at Orchard), where every macOS or Xcode update kept breaking something. We eventually moved to Namespace, getting us out of the runner operating business with its minute based ephemeral workers, and speeding up builds with its Bazel remote cache, all while cutting the bill on top of it.

More recently, I jumped on the AI side, building a Go Slack assistant for our ops and analytics workflows, taking inspiration from OpenClaw. Under the hood it’s a multi-step, tool-using agent loop (think, act, observe) on top of a multi-provider pool (Anthropic, OpenAI, Gemini), with long term memory backed by Postgres and pgvector, a runtime MCP host, sub-agents and scheduled tasks. A great excuse to get my hands dirty with how these agents actually work.

For almost two years, I was the only one handling all of this on my own, before finally recruiting my current colleague to share the load.

It’s been a great couple of years, on a very different scale and pace than before, and I learned a ton along the way.