Today, I'm moving to San Francisco. Moving to the United States to work on a startup has been one of my biggest dreams ever, and it became reality when my O-1 was approved shortly after my 25th birthday two months ago. I've been working on this
As another eventful year is coming to an end, I'm continuing my annual tradition of reflecting on 2025. Last year was marked by significant change: I joined Inngest in April 2024, which has come to be one of the best decisions I've ever made. This year,
A couple days ago, I pulled the trigger and moved this blog from Next.js to Ghost. You can read more about the process behind this decision in my other piece. In this post, I want to focus on how the new stack works, and why I think this should
I've always enjoyed using good software. Convenient tools. The newest thing. Over time, I've come to realize that none of this matters if you don't own your data. Or if you have to worry that a company providing the platform you're on
Claude Code may be one of the most exciting product releases since ChatGPT. It's been out since early February this year and I started using it a couple weeks ago, but it's consistently blowing my mind. I had been planning a project to replace a critical
Another year is coming to a close, so it’s time for another annual review! This has become a personal tradition, check out last year’s review if you haven’t done so already! Early in 2024, I was working hard on building CodeTrail, a new take on documentation for
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
Hey! It’s been pretty quiet around here for a while — more than I’d like but it’s been a busy couple of months since I joined Inngest earlier this year in April. I’m completing some personal projects too at the moment and trying to get back to
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
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
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
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
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
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
In the coming decades, there’s only going to be more software to build, operate, and scale for platforms we’re only just inventing, with code running on nearly everything we interact with day to day. To help advance the current frontier into AI, which is built on massively distributed
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
Rich-text editors power knowledge-sharing and content creation on the web. Back in the day, WYSIWYG editors for building blogs and submitting comments on websites were all the rage. Nowadays, products like Notion lead the way in simplifying the editing experience while enabling powerful use cases. If the editor works, we
I’ve recently had the honor to debug a Python script that was consuming more memory than it takes to run a full-sized LLM locally. The purpose of the script wasn’t anything out of the ordinary, it was reading a CSV file and performing some analytics on it. The
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
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
Tonight, 2023 is coming to an end, and I’m still wondering where the last months went. I feel like a broken record repeating that time is accelerating year by year, so naturally I’m going to say that the past twelve months felt like the busiest yet. Platitudes aside,
Learning new languages, sports, and other skills is hard work. You’ll have to put in the hours to get better, step by step. Even if you have a natural inclination toward a specific skill, your brain isn’t designed to excel at, let’s say, freestyle ice skating. You
Conventional wisdom tells founders it’s better to be a small fish in an ocean as opposed to a big fish in a tiny pond. For me, the thought of starting a new business when well-funded competition existed was daunting. Recently, I’ve changed my mind on this. Let’s
Recording videos always seemed like a huge ordeal to me. For a good demo, not only do you make sure that everything works, hope that you’ve selected the right mic (sorry Tim), and select the right window to record, you need to set up the environment just right. This
When the whole world is fighting for your attention, it’s hard not to get distracted. It’s just so easy to drift off. Maybe the following situation feels familiar: You wanted to read your DMs and sneak a peek of your feed. Suddenly an hour has passed, leaving you
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
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
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,
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
Even though there’s no way around handling JSON in web services nowadays, the developer experience between different programming languages varies significantly. I had the joy of fiddling around with Go’s particular implementation a while ago, which motivated me to do a follow-up post on embedding types in Go.
I can’t say for sure whether it was late 2012 or early 2013 but around that time I probably wrote my first, very scrappy, lines of code. Back then it didn’t dawn on me that I was about to embark on a career path that would open up
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
While ML is all the rage right now, it is important to understand the fundamentals powering the incredible breakthroughs in fields like natural language processing (NLP), computer vision (CV), and generative AI in the past years. While there are many resources available, Andrew Ng’s courses at deeplearning.ai have
I’ve always loathed working on tasks that don’t create actual value for anyone, such as preparing read decks for potential investors. You know that nobody really takes their time to read what you spent days of your life working on, but traditional institutions and government programs with a
Designing user interfaces can seem like a notoriously hard task, especially when you’re used to seeing highly-polished results from the work of multiple designers in bigger teams. When you only have an idea in mind, it can be hard to get it onto (virtual) paper. Most design sessions started
In recent months, with the general availability of increasingly powerful large language models (LLMs) like GPT4 I’ve noticed a change in my work-related browsing behavior, away from blogs and forums like StackOverflow. The reason for this is simple: Whereas the good old internet required you to get really good
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,
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
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
You might have been wondering why my publishing cadence has shifted back to the initial bi-weekly schedule instead of the weekly posts you’re used to. There are multiple reasons, the main one being that I’m working hard on Anzu, the new company I’m founding. As with all
Last night, I started watching a recent show which includes dialogues in multiple languages, so naturally, I wondered if I could use OpenAI’s Whisper model to transcribe and translate audio to subtitles in real time. I hadn’t used it in the past, so there was some initial research
Every day, someone out there has a new idea worth looking into. Maybe it’s a problem they came across at work, or maybe it’s an issue a friend told them about. Now, you might be thinking more people are facing the same problem and making the solution available
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
Let’s start this post with a simple observation: The better students are prepared for the real world, the easier it is to onboard them after graduation. The more skills students pick up at university, the more attractive they become to future employers. The more the economy benefits from talented
Around four months ago, I shared a story of how we were trying to solve the problem of sharing code for Anzu. As we are building both our frontend and backend with TypeScript, we thought it should be easy enough to share parts between both sides, from types to functions.
Happy new year! A lot of things have been set in motion since my recent announcement, so I’ll focus on a shorter guide this week, which will nonetheless be very interesting if you’ve always wondered what bitwise operators could be useful for. Imagine you’re working with a
I’ve always enjoyed building software and solving problems. Back in 2012, I started hacking around with Java to build Minecraft plugins for me and my friends to enjoy. It took way longer than I’d like to admit until I got the first version running successfully, and I absolutely
2022 is slowly coming to an end and I’m still trying to process this eventful year. As with every year, I had set out to follow a personal roadmap the past year, consistently building toward the long-term goal of running Anzu with my good friend, Tim. On the other
Setting up billing for your SaaS product inevitably forces you to think about billing periods: While you may opt for a monthly subscription plan, certain customers may prefer different schedules like annual or semi-annual payments, especially when you’re closing enterprise deals. Chances are you’re using an external provider
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
React has been out in the open for almost a decade now, and the ecosystem has grown exponentially. Pretty much every large company uses React for parts of their stack, and few competing frameworks have come close to attracting a similar market share. I think there are two reasons for
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’
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
When you’re building your first product, you need something going for it. Especially if you’re not solving a completely unsolved problem (read: customers would accept anything, no matter the lack of polish), you need to offer an experience that beats the existing solution. You may remember me writing
A couple of weeks ago, I ordered the Pro Apps Bundle for Education from the Apple Store. What I didn’t expect was insight into the processes of the biggest corporations. For now, let’s step back and follow the events! Initially, I was interested in getting a copy of
When I think about “successful” companies in the SaaS space, there is a group that quickly comes to mind. Irrespective of revenue numbers, or knowledge about internal processes, some teams keep on delivering and people notice. In the following, I’ll go over some products I’ve been using and
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
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’
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
As teams grow, managers invariably start to think about dividing the former team into smaller groups working on specific features or areas, in most cases supported by people or small teams that focus on tooling, infrastructure, and other “meta” tasks that enable engineering. In some cases, external advisors are brought
This post is the first part of the Behind the Scenes series on building the first iteration of Anzu. While we keep on building and improving the next iteration of Anzu, I felt it would be useful to write down what went well with the first iteration, and what didn’
Most software companies don’t ever get to see a steady state, where the core product has been built, the rate of innovation decreases, and maintenance and minor improvements become the primary workload. In this world, priorities shift from figuring out the product, to ensuring customers are happy and keeping
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
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
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
When building the first iteration of the AWS provider for Anzu, I wanted to provide an easy way to deploy containers on AWS ECS. While newer versions of the provider offer low-level resources, back then I believed that one resource could deploy all related dependencies as well. While I strongly
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
When browsing social media and adjacent sites, I’ve always wondered how ratings are implemented. This may sound pretty boring, but let me raise an important example: Imagine you’re browsing a community and searching for the most popular posts. In most cases, you’ll only find recent posts because
While some projects require complex setups and resources from different cloud providers, sometimes you just want to run a container in the cloud and we hear you! Today, Anzu is introducing Managed Containers, a dead-simple way to get your container running in the cloud. The best part? For exploration purposes,
The DataLoader concept has become popular with GraphQL, combining batching and caching of database requests, API calls, and any other resource fetching implementation. Usually, DataLoader instances are used to fetch entities from a database, using one or more keys. Some DataLoaders receive a single key and return a single or
In last week’s post, I wrote about how Anzu Services help engineering teams bridge the gap between the cloud and their codebase by leveraging code generation and the provider ecosystem to connect resources to services within seconds. This week, I’ll focus on Anzu Dev Environments: Developing software locally
At Anzu, our mission is to help teams move faster, happier. We want to help make the work of building and shipping services fade into the background, so you can focus on building instead. One of the big pillars to achieving this mission is to reduce the effort associated with
In almost forgotten times, we used to deploy our services to virtual machines by tunneling into the machine, downloading the latest code or image, and running the workload manually. Mostly, this deployment model has been superseded by more automated solutions like hosted container services and PaaS products, but the appeal
Imagine you’re about to build a site builder with multiple content blocks. Users can add paragraphs, callouts, links, and whatever else you can imagine. You wonder how you could model this in your database, as sites should be linked to all connected blocks, but you do not want to
Building and maintaining software and web services has become increasingly complex in the last few years. Integration work across service and cloud providers, delivering commodity features, and ensuring compliance with standards such as SOC II and ISO 27001 slows teams down with busy work and little leverage. I think we
Two weeks ago, I wrote about enforcing required status checks in GitHub actions. This was required in scenarios with sharding or running tests in parallel. Today, I wanted to extend this to setups with multiple services, which create a different dynamic: When files in a service change, you want to
Whenever I needed to route traffic to one of my side project deployments, I typically chose nginx in the past. I knew the setup process, including requesting certificates using an ACME client like Certbot with LetsEncrypt. Over time, however, adding new deployments started getting tedious. A big issue of the
A very important GitHub feature for teams is to configure branch protections. These typically include requiring pull requests and a minimum number of reviews, preventing force pushes to main branches, signing commits, and most importantly, passing status checks. Status checks can be added by external services to commits to signal
Building and pushing Docker images is one of the most common tasks in the deployment pipeline of most engineering teams. We usually want to build the images ahead of time to create a repository of images we can use for our deployments, or are required to do so in case
You might have experienced a scenario where a traditional foreign key constraint would be violated, for example, when creating circular references or having multiple entities depend on a resource where all rows are dropped at once. Sometimes, rows referencing deleted or updated entities should stay around, sometimes, the deletion process
Being a self-taught software engineer, I always wondered what I could take away from more academic paths to computer science. If you had asked me a couple of years ago, I would have probably said that a university CS class wasn’t for me, but in the end, people just
Usually, we go through our day focusing on things at work, side projects, or whatever it is that we spend our time on. We don’t even think about why it is that we choose certain tools, services, and architectural decisions over others. We generally trust that the experts at
In object-oriented languages, Polymorphism is an elegant usage of inheritance that allows creating generic and specific pieces of functionality for a set of classes. The common example of vehicles is useful here: Imagine having a top-level class for all vehicles with some common information such as a license plate and
Building a consumer-oriented service where users can submit their own content, be it profile pictures, images, or any other media that is shown to other users on your platform requires careful planning ahead of time. Especially when you want to build a safe environment for your users, allowing people to
Querying databases often happens in multiple network roundtrips. Especially when you have multiple operations that depend on the outcome of earlier queries, you’re dealing with state. In most cases, those network roundtrips are negligible, but what if you wanted to reduce it down to sending just one request containing
Building user interfaces involves a lot of layout work: Placing controls, aligning list items, adding spacing, sticky elements, and other details that create an easy-to-use, low-friction interface. Depending on the platform, performing these tasks might require a couple of minutes, but there are cases when you spend much more time,
While Go doesn’t come with the typical language concepts for inheritance-based type hierarchies‚ it provides a powerful concept to reuse parts from other interfaces and structs, using embedding. Using the example from Effective Go, for interfaces, embedding allows borrowing pieces of an implementation by embedding types type Reader interface
When you manage websites with more than a dozen pages, it can get hard to make sure search engines like Google know when to index newly-added content. Some pages may change frequently, and the classic way of publishing a page, then waiting a couple of days to see if Google
Setting up the communication layer between services can be a cumbersome task, even if they’re written in the same language, built on top of the same framework, and running on the same infrastructure. Every minute spent debugging weird connection issues, malformed payloads, and other parts that occasionally break could
In my guide on designing scalable APIs, I emphasized implementing strict limits to how many entries are sent back for endpoints that return multiple items. The idea was that as long as you’re not completely sure that the data to be returned is limited to a small number of
As we’re getting closer to the last days of the year, I looked in the rearview mirror and collected what happened in 2021 and, well, it’s a lot! Before I dive into the work and projects that defined 2021 for me, I want to make it clear that
Picking the right underlying system for generating unique identifiers (read ID generator implementation) throughout your application is an important task early on. Even if it doesn’t seem that important, having to revert a bad decision made early can require a lot of time and effort you’d gladly spend
When averaging values, sometimes you want to penalize inequality or variation, for example, when you value similar medium values more than extreme differences. When using the arithmetic mean, you merely get the same sum, regardless of having the same results or huge differences between the values. To illustrate the differences
Graphs can contain a lot of unnecessary edges that make computations a lot more demanding. It is also harder to reason about the dependency structure of a graph with a lot of edges. In the last guide, I implemented topological sorting and gave a basic introduction into what directed acyclic
Imagine you want to bake a cake: There are multiple tasks you need to follow to end up with the final dish, from gathering and preparing ingredients over setting up the oven to finally baking it. Most, if not all, tasks depend on the completion of their predecessor. To represent
Firecracker was designed by AWS to run untrusted workloads in a secure environment for their Lambda and Fargate services while retaining the fast startup times and low resource overhead you expect from serverless functions and containers. Represented as microVMs, workloads deployed with Firecracker are extremely lightweight, so that a given
Sometimes when building software, I run into problems that are extremely weird to grasp, and usually connected to something much more simple that wasn't immediately obvious. I think we often deal with small frustrations and once we have a fix, we move on, ignoring the educational value: Let
Recently, I wanted to access the workouts tracked and saved on my Apple Watch with a Swift application, as I needed the coordinates of every workout that I recorded so far. Initially, I wasn't sure whether this type of data was accessible at all, but luckily, everything was
Building software is hard. Typically, engineering teams use dozens of services for building, deploying, monitoring, and analyzing their product, as well as providers for billing, internal tooling, customer service, and so on. Once a product is deployed in production, it is continuously refined and expanded with new features, which may
How many third-party services and resources does your application use? For a regular web application, you need a place to host your frontend, deploy your APIs, store files, a database for user accounts and other application data, maybe some queues for decoupling tasks, monitoring integrated with every service you deploy,