Systems Architecture
Before joining Inngest earlier this year, I had never used Redis (or its successor, Valkey) or any comparable system. Whenever I planned data persistence for a new service architecture, I would choose a reliable data store like Postgres. I would argue that ACID guarantees and a track record of stability
Systems Architecture
At Inngest, we serve hundreds of millions of events per day. Each event can trigger a function run comprising multiple steps. Users can return blobs and other data from these steps, necessitating incredibly fast reads and writes to our data store to keep latency as low as possible. Function runs
Systems Architecture
In my last post, I talked about the benefits of using interfaces in Go. In short, interfaces are a powerful tool to specify the behavior of objects. However, Go interfaces lack a mechanism to specify a predefined set of errors that can be returned to narrow the definition, such as
Systems Architecture
Interfaces hide implementation details by specifying the capabilities or behavior of an object. This concept has appeared in different programming languages over time, using different terms like traits or protocols. The same rules apply in Go, take the classic example of io.Reader: type Reader interface { Read(p []byte) (n
Systems Architecture
Imagine you’re building an app and want to ensure that requests don’t feel slow for the end user. Let’s say you’re working on a signup flow that needs to send an activation email and update external systems like billing and a CRM. You don’t really
Systems Architecture
In most successful companies, products and their underlying infrastructure are constantly evolving to changing needs and growing demand. Shipping new features, improvements, or other changes can require careful planning ahead of a release. While you can try to imagine and rule out different failure scenarios ahead of time, you never
Golang
The internet has grown from a couple of research lab sites to a vibrant ecosystem of content and services. Without the ability to resolve human-readable names to machine identifiers, however, it’d be impossible to find anything in the ever-growing web of interconnected systems. In November 1987, RFC 1034 and
Systems Architecture
You might have noticed a recent addition to the top right corner of this blog: I’ve added a global search experience. More specifically, I’ve implemented a hybrid search solution based on OpenAI Embeddings, Supabase, and PostgreSQL full-text search. In this post, I’d like to run through the
Systems Architecture
Now that everyone and their dog have tried out Generative AI, teams around the globe are wondering how they can incorporate LLMs into their products for an upcoming fundraising effort or, hopefully, to create a great experience for their customers and solve some real problems. In recent months, countless reports
Systems Architecture
For the last couple of days, I pushed through the tedious task of setting up a Markdown parser and formatter in Java consistent with our existing system written in TypeScript. For this first iteration, I decided to customize flexmark-java, a popular Markdown parser library for Java based on the commonmark-java
Systems Architecture
Recently, I’ve gotten to wrap my head around versioning again. If you’ve been following this blog for a while, you might remember that I wrote a post about API versioning in mid-2021. Back then, I focused on versioning API-first developer products. This problem was relatively contained, we used
Electron
Last week, I wrote about releasing Electron applications on macOS, going into detail on the specific steps required to go from source code to packaged application. Building your app on your development machine is one thing, but ideally, you want to publish new builds as soon as a commit is
Electron
Staying close to last week’s post on figuring out the state architecture for Electron applications, this week I’m looking into builds for macOS. Even without Electron, building applications for macOS entails a lot of steps to go from your code to shipping a packaged binary to your users,
Electron
In some communities, Electron has become a controversial choice for building new applications, yet it offers a nearly unmatched possibility of moving fast compared to native frameworks like SwiftUI, especially when your team is experienced in building web applications. For an upcoming product, we’ve decided to build an MVP
Gradients & Grit
In case you didn’t see the news, I recently launched Gradients & Grit, a new publication at the intersection of software engineering, AI, and UX. In our first issue, we introduced PromptCanvas, an interactive spatial prompt experience. As the name says, building PromptCanvas involved building a canvas interface similar
Systems Architecture
Typically, installing one of the major Linux distributions like Ubuntu or Debian requires going through an interactive installation wizard. This is great when you have a screen and keyboard but less ergonomic in a virtualized scenario, for example when you’re running in qemu/kvm. I recently learned that, luckily,
Systems Architecture
Lately, I’ve been exploring x86 Linux machines for building and running a Kubernetes development environment. Since I’m using an Apple Silicon MBP as my daily driver, I had to get creative and tried a couple of options ending on a pretty robust workflow I wanted to outline. Throughout
Systems Architecture
Kubernetes is equally loved and loathed for its extreme flexibility which comes with a high cost of complexity. For a research project, I was looking into ways to extend the Kubernetes Scheduler (kube-scheduler) with awareness of FPGAs. More precisely, I wanted to make sure that each node could advertise several
Systems Architecture
If you’ve worked on a product that depends on multiple services and surrounding cloud resources, you’ve probably wondered about the best way to set things up for local development. Most teams default to the good old Docker Compose setup supported by some scripts, and that works until you
ClickHouse
ClickHouse is the up-and-coming solution for processing large-scale analytics data without having to worry about the complex architecture that is usually required. Originally built by Yandex for their web analytics competitor to Google Analytics, ClickHouse has found widespread adoption (Cloudflare, Vercel via SplitBee, Microsoft, Uber, Bytedance, Stellate, and more) for
Systems Architecture
When working on projects in the past, I’ve always wondered about the perfect time to lock down interfaces. In the first steps of building an idea, you’re not quite sure what data you need to exchange yet and which operations should be exposed via APIs. Perhaps you don’
Systems Architecture
This post goes over some of our architecture work for the first iteration of Anzu. We’re currently hard at work building the next big step to get closer to our vision of helping teams ship faster, so make sure to check this blog out for updates regularly. If you
Systems Architecture
This post is the second part of a series on exploring the benefits and drawbacks of engineering for the application and database layer. If you haven’t done so, check out the first post on reducing database roundtrips. When you’re working with databases, you may be inclined to offload
Anzu
This post is part of the Behind the Scenes series on building the first iteration of Anzu. While we’re working hard on the upcoming iteration, I felt it would be useful to look back on the achievements and downsides of the first version of our product. If you didn’
Systems Architecture
Relational databases have been at the foundation of the internet for the past four decades. What was built for business workflows in the past is now used for building dynamic applications powered by user-generated data. Sortable relations are one of the most important features in database modeling: Whether we’re
Systems Architecture
I’ve been using TypeScript and Node.js as a key part of my stack for more than half of the last decade. Since then, many tools have come and gone, but one problem has stuck around: Sharing code. In many cases, you’ll be working on multiple services, across
Systems Architecture
From early on, we’ve learned to deduplicate data and use concepts like foreign keys to make the most of our relational databases. Cascading operations are great to handle implicit updates and retain relational integrity, but somewhere, there is a case for denormalization. Recently, while working on Anzu, I came
Systems Architecture
Decoupling services usually involves some form of communication, preferably asynchronous through queues that are populated by one service and consumed by another. AWS SQS offers regular and FIFO queues that help you with exactly that use case, but, as always, the devil is in the details. Depending on how long
Systems Architecture
Note: This post is the first part of a series on exploring the benefits and drawbacks of engineering for the application and database layer. If you’ve ever wondered whether you should build this feature using a database query or as part of your application layer, this post is for