Looking Back on 2024

Understanding When to Use Redis

The First 120 Days at Inngest

Sharding high-throughput Redis without downtime

Enhancing Scalability and Reducing Latency Without Missing a Beat

Restoring Go Errors in gRPC Services

Harnessing the Power of Go Interfaces for Decoupling and Scaling at Inngest

Zero-Downtime Migrations in Producer/Consumer Systems

Derisking Product Rollouts with Feature Flags

Building a DNS message parser in Go

Joining Inngest

Building a Hybrid Search Experience

Why Documentation Matters

Building outstanding rich-text experiences with ProseMirror and React

Reducing Python Memory Usage by 97%

Scaling Generative AI Adoption with Software Engineering Principles

Working with Parsers and ASTs

Looking back on 2023

Learning to enjoy trying new things and looking stupid

On Competition

Recording Better Demos

On Distraction and Procrastination

Product Versioning for Fast-Moving Teams

Setting up Hosted macOS GitHub Actions Workflows for Electron Builds

Releasing Electron apps for macOS

Syncing State between Electron Contexts

Go Embeds and JSON

Enhancing LLM Applications with Real-time Data Sync

Looking back on a decade in software engineering

Building Canvas-Based Web Applications

Exploring Production-Ready AI at the Frontier of Research

Introducing PromptCanvas, a spatial prompt interface

From regression to neural networks

Writing damn good decks with LLMs

An engineer’s guide to UI design

On the future of coding blogs in a world of LLMs

Instant Linux VMs without the Installation

Reproducible VMs for Local Development

Extending the Kubernetes Scheduler

Adding Context: The First Weeks

Generating Subtitles in Real-Time with OpenAI Whisper and PyAudio

The OS for building products

Improving Local Development with Atlas

The most memorable computer science education is applied

Using Static Code Analysis to Share Types Between Services

Nested Flags with Bitwise Operators

What's Next

Looking Back on 2022

Calculating Rolling Billing Periods

Storing User-Defined Attributes in ClickHouse with Nested Types

Building delightful React applications has never been easier

Indirection is the antithesis of velocity

Serializing Data between Systems with Anzu Values

Betting on Delightful Products

Experiencing How Big Corporations Work for 240€

Observations on Successful Companies

Offloading Execution Flow to the Database

Running untrusted code in short-lived environments for Anzu v1

Building Sortable Relations with PostgreSQL

Making Architects work in Software Teams

Anzu Behind the Scenes: Why Resource Management Wasn’t It

Steady State means Continuous Rewriting

Sharing Code in TypeScript is (Still) a Mess

Balancing Normalization and Revision History

Handling Long-Running Jobs with AWS SQS

Deploying Containers on AWS ECS Using the SDK

Reducing Database Round-Trips with Boring Queries

Measuring Popularity or How Likes Don’t Tell the Full Story

Running Container Workloads on Anzu with Managed Containers

Improving Cache Hit Ratios with Connected DataLoaders

Introducing Anzu Dev Environments

Bridging the Gap between the Cloud and Your Codebase with Anzu Services

Deploying Docker Containers over SSH

Modeling Polymorphic Relations in Postgres

Making teams move faster, happier.

Required GitHub Actions Jobs in a Monorepo

Routing Traffic for Dynamic Deployments using Traefik

The Required GitHub Status Check That Wasn't

Building and pushing Docker images within GitHub Actions

Understanding Deferred Foreign Key Constraints in PostgreSQL

Looking back on Introduction to CS

The Complexity of Building Software in 2022

Getting the hang of Polymorphism in object-oriented languages

Reviewing User-Generated Content with Interactive Slack Messages

Offloading Program Flow into PostgreSQL with Temporary Tables

Layouting across platforms

Important Rules of Embedding Types in Go

Indexing Pages Programmatically Using the Indexing API

Communicating between services with gRPC

Paginating Large, Ordered Data Sets with Cursor-Based Pagination

Looking Back on 2021

Choosing an Implementation for Unique Identifiers

Exploring the Geometric Mean

Decreasing Graph Complexity with Transitive Reductions

Scheduling Tasks with Topological Sorting

Running Untrusted Workloads with Firecracker and containerd

Solving the unexecutable executable

Accessing Workouts with HealthKit and Swift

Reducing SaaS Complexity

Infrastructure-as-Code as Single Source of Truth

Updating Notion Pages on a Schedule with GitHub Actions

Generating Dynamic GitHub Actions Workflows with the Job Matrix Strategy

Preview Environments for every Pull Request with Pulumi and Vercel

Containers as Code with Pulumi and Docker

Cutting Production Release Duration By 80%

Implementing Transactions with Side Effects

An introduction to R

Communicating between Java and Go using gRPC

Built it, but nobody came

Analyzing Blog Performance Using R

Setting up Algolia DocSearch with Next.js

Multi-Stage Markdown Processing with remark

Improving DataLoader Stack Traces

Transforming Exponents, Radicals & Fractions

Motivating Employees with Stock Options

Faster TypeScript Feedback Loops with esbuild

Designing APIs to Last

Observing WebSocket infrastructure with Socket Inspector

Rendering Remote Images with AsyncImage

Versioning Features for Sustainable Product Evolution

Improving Content Discoverability with Topics

Locking and Synchronization for Node.js

A primer on SSO with SAML

Picking Monitoring Methods to Increase Observability

Improving observability with annotated build information

Sending Contact Form Submissions to Notion

Improving releases with service-splitting

Running a commit-based release infrastructure

My 2021 Swift Student Challenge Submission

Processing Markdown with remark and unified plugins

The Future of Multiplayer: Cloudflare Durable Objects

SwiftUI Meets Swift Playgrounds

Visualize Regressions with Playwright Video Recording

When Velocity Implies Simplicity

Efficient Caching with Reduced Roundtrips

One Semester In, Five To Go

Preventing Increasing Fragmentation

Instant Full-Stack Insights with NewRelic

Secure Asset Management and Upload with S3

GraphQL-powered API Integration Tests

Exploring State: State Machines

Finding The First Iteration

Centralized Validation with GraphQL Scalar Types

Deliver context-aware navigation with Push Evaluation

Building Functional Stack Navigation

Introducing Stapel

Looking Back on 2020

Multiple App Environments Using Xcode Schemes

Supporting Universal Links with SwiftUI

APNs Environments and Push Notification Delivery

It's About Time

Preview-Driven Development with SwiftUI

State and View Composition in SwiftUI

Scraping Country Codes

Boring Technologies, Reliable Foundations

Getting Into iOS Development with SwiftUI

Starting Lasting Side Projects

The Pace of Studying in 2020

When (not) to use pg_dump

Building Productive Habits

Digitizing My Maths Studies with TeX

Rebuilding my portfolio using Next.js & TailwindCSS

My Favorite Tools in 2020

Reaching Remote Acceptance

Rapid TypeScript Development with esbuild and Estrella

The End of an Era for Public Container Image Registries

Common Pitfalls in Go Application Development

Fundamental Design Decisions for Scalable Systems

Forwarding Incoming Mails with AWS Lambda and SES

Building Powerful Integrations with GitHub Apps

Seamless End-To-End Browser Tests with QA Wolf

Accessing ECS Task Metadata at Runtime

Tunneling Local Applications with SSH and Caddy

Handling GraphQL Errors using Sentry

The Weirdest Error I Ever Debugged

Documenting Design Decisions using RFCs and ADRs

Scaling Release Systems

Ship Early and Ship Often

Getting Started with Electron Application Development for macOS

Picking the perfect Serif typeface

Bootstrapping a Portable Cypress Setup for Blazing-Fast Browser Tests

Measuring Velocity: The Case for Electron

Deno and the future of Node.js

Building a Testing Culture

Managing Your Infrastructure as Code with Pulumi

Rapidly Setting up GraphQL Data Fetching in React

Building Go Test Suites using Testify

Verifying Asymmetrically-Signed JWTs in Go

Building Composable Go Applications With Interfaces

Conquering Randomness with Composable Go Application Design

Testing Web Applications in Go

Recovering HTTP Handlers In Go

Browser-Only React Components With Suspense

Redesigning My Portfolio for 2020

Configuring Jest Snapshot Resolvers

Real-Time Postgres Change-Streaming With lode

Utilizing the data layer: Deadlock Relations with Deferred Constraints

Utilizing the data layer: Complex UPSERTs in Postgres

Supercharging Jest with Custom Reporters

Utilizing the data layer: Conditional INSERTs in Postgres

Building an Authoritative DNS Nameserver

Global Service Deployments with Anycast and BGP

Goodbye 2019, Welcome 2020

Back to Bare-Metal: Building and Hosting my Metrics

Improving Static Assertions with Snapshot Tests in Go

Scaling Network Concurrency in Go

Understanding Go's context package

Tinkering with Global WireGuard Deployments

Parallelized Batch Processing in Go

A Brief GraphQL Day Bodensee Recap

Handling Concurrent Go Workflows

JavaScript Generators And What They're Used For

Inspecting Kubernetes Deployment Logs with kail

Boost Your Team's DX By Formatting All Git Commits

JAMstack Conf London: That's My Jam!

Retrospective on GraphQL Conf & Prisma Day

Automating my open-source projects with CI/CD workflows

Accessing Kubernetes services locally using kubefwd

Reaching Consensus: GraphQL Input Unions

What's Next?

Choosing the Right Go Web Framework

Debugging Google Cloud Pub/Sub services in production

The Lifecycle of Side Projects: Planning & Early Stages

Updating your GitHub status with ghstatus

The State of GraphQL × Go

Setting up Kubernetes Dashboard

Provisioning Kubernetes clusters

Empowering CI/CD workflows with compose-deploy

Simplifying Docker deployments with compose-deploy

Bootstrapping local Kubernetes clusters using kind

Introducing aqueduct

Introducing GraphQL Jaeger tracing middleware

Adding tracing to your GraphQL services with Jaeger

Designing my new portfolio