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,
About five months ago, Notion launched their long-awaited public API. The team initially delivered basic features and continuously improved the surface with more functionality and block types to support a growing number of use cases. I use Notion for, drum roll, note-taking. I create a page every day to take
GitHub Actions is becoming one of the major CI providers, benefitting hugely from the tight integration to GitHub's other features. In this post, I'll walk through a feature that is seemingly inconspicuous but can become quite powerful if used right: Job strategies, and more precisely, the
Testing the changes in a pull request isn't intuitive: checking out the branch, waiting for Docker to launch all service containers, keep waiting for another bit, then getting to test the actual PR. By the time you reach the last step you might have forgotten what you initially
In my recent post, I talked about how we reduced deployment times of our Infrastructure-as-Code workflow with Pulumi. The benefits of managing all resources you're deploying in a declarative way are manifold, including observability of what you're running, security in the sense of using encrypted secrets,
The faster you can release changes, the faster you can ship new features, fix bugs, and solve incidents. But there's more: The less time it takes to think about deploying to production, the more time your engineers get back to work on meaningful tasks or spend their time
Transactions are an amazing concept: You perform some work, and only if everything succeeds, the results get persisted. If something in between fails, the system will simply roll back and thus undo all changes. Until a transaction is committed, no one can see its changes. Most relational databases support transactions
When you're dealing with data that you want to explore, analyze, and visualize, you have a lot of options. Most programming languages have packages and libraries that add the capabilities you might need, but there's one ecosystem that stands out: R. Built over the course of
Sometimes you're working between two systems, running in different processes, based on different programming languages. If you want to get instructions or data across those two, you'll need a layer that handles communication. Naturally, you'd rather spend your time building the actual thing rather
Like most engineers, I tend to have a bias towards action. Getting started and building things is what I really enjoy, so naturally, I start a lot of side projects. Over time, I've tried to limit those to specific problems I've had myself, building on Paul
When putting out content on the internet, it's interesting to see how everything performs, especially over time. While some topics might gain relevance, others may become less important. This is affected by broader trends in the industry, but also the nature of the content itself. Some blogs are
When there's a lot of content to go through, finding what you are looking for can become tedious. It's no surprise that most users will just bounce when they cannot find a resource in a certain amount of time. While structuring your pages can already help
Markdown is a great format to write formatted content, be it blog posts, documentation, or anything else that comes to mind. With support for interactive elements such as media, code blocks, and even LaTeX, the vast ecosystem provides all tools you need to get everything running. Built on micromark, a
DataLoader is an elegant solution for batching access to your application data layer, and optionally caching it for subsequent access. With the rise of GraphQL, DataLoader has grown in popularity too, as it can be used for accessing data in multiple layers, caching it the first time, and returning the
Preparing for my exams around Statistics and Macroeconomics, I've been using a couple of rules a lot for transforming and solving equations. When they were first introduced, I didn't attempt to memorize them but after having spent a great time going through exercises, I've
Compensation of employees can take many forms: Usually, salaries form the basis, with additional benefits added on top. For startups with less liquidity at hand or companies searching for ways to incentivize employees taking ownership and staying for the long term to build and grow the business, there are alternative
A short feedback loop between writing and running code is critical for seeing how changes apply to a codebase. The longer the time to see results, the more inefficient and cumbersome it becomes to write and test software. Usually, delays are caused by build tooling, which performs steps like compiling
In the era of Software-as-a-Service products, we have seen a transition from interacting through user interfaces to interacting through APIs. Some products are available mainly through such a communication layer, enabling automation, and seamless integration between services. Whether you use Stripe for billing, Shopify for commerce, AWS for a variety
Real-time features on the web are usually built around WebSockets, bi-directional data channels, which send messages back and forth. While there are a lot of clients for testing network requests, there are limited solutions for observing WebSockets over time. Today I'm introducing a new application I've
With WWDC21 being kicked off officially, all technologies have received major upgrades, including SwiftUI. One of the bigger changes, a new view has been added to solve a complex problem SwiftUI developers faced until now: Loading remote images. The new AsyncImage view allows to load and display any arbitrary image
When you're working on a product that is constantly evolving, adding, deprecating, and deleting features not only has to be communicated with your customers in advance, but often you have to maintain multiple versions. While you should never have to maintain more than a handful of versions of
Previously, it was impossible to continue reading posts on similar topics as the one you just read. If you were starting on the main page and wanted to find a post on some specific topic, the only option was to go by the title, which doesn't always tell
When building software that is accessed by multiple actors concurrently, such as APIs and web services in general, you sometimes need to restrict access to only a couple of entities, maybe even just one at a time. In multi-threaded systems, it can be important to have exclusive access to a
Implementing features like Single Sign-On (SSO) usually is one of the loathed tasks when building a SaaS product. Bigger customers, especially in the enterprise segment, will require integration with their identity providers like Azure AD or Okta, allowing them to sign in with their existing company account. For companies, using
Monitoring is one of the most important areas of maintaining a product. Knowing when something breaks or degrades the performance for your users is incredibly important, and to be efficient when investigating, you'll need to do some work upfront that'll help you through hard times. Observability,
In my recent posts on managing a commit-oriented infrastructure, I explained the benefits of deploying services of one specific version. This version would be the hashed Git commit reference, or commit SHA. When running this kind of setup, you might encounter the question of which version is running at the
With Notion launching their public API beta a couple of hours ago, I wanted to try out to pipe my newly-added contact form submissions to a Notion database. Database pages in notion are made up of a combination of page properties and content. Properties such as the page name (title)
Last week I published a piece on how running a CI-driven commit-based release infrastructure can improve your time-to-release drastically. I noticed that it wasn't super clear on how to get services running that aren't typically bundled or packaged up like container images, for example, frontend deployments.
We spend a huge time thinking about building our products, but less about the pipeline that delivers features from engineering to production. Ideally, we want to test the latest changes before they're released to all our users, even if we carefully hide them behind feature toggles. We also
In a previous post, I teased the topic of this year's Swift Student Challenge, which was about creating a short interactive experience using a Swift playground, with roughly three minutes of content. Since the submission deadline has passed for some time now, I'll elaborate on what
Markdown is one of the most popular formats for writing anything on the web, ranging from documentation, to everything on GitHub, to blog posts. The CommonMark specification provided a standardized collection of supported tags to use for formatting and set readability as the primary goal. Extending markdown with new elements,
A lot of today's applications offer some kind of real-time collaboration feature. Also referred to as multiplayer features, live chat, seeing your colleague's cursors, or working on a document at the same time, everything around improving collaboration has been on the rise recently. Building synchronized features
Continuing the long-standing tradition, together with this year's WWDC, Apple has announced the Swift Student Challenge. To participate, you'll have to prepare an interactive Swift playground (that can be experienced in three minutes). I participated in this year's challenge and wrote up my experience
When you're building a web application, you likely want to make sure the most important features don't break when you change business logic. Testing manually isn't feasible when you perform changes often or work with a team that does. For these cases, you'
Building products is hard. You have to think about the problem you want to solve, the customer you want to delight, design a product through multiple iterations and improve continuously. In small teams, all hands are on the product, working on anything else can be very expensive in terms of
Imagine you're building a service that heavily depends on content served by an external provider. Sending a request each time a resource is accessed would quickly lead to rate-limiting, so to provide an improved experience, we want to introduce caching. If a cached resource expired or was not
When I was about to start studying last fall, I wasn't sure what to expect. Around four months and four exams later, I think I have created a routine that's working out for me. My first semester is almost over, and it went by faster than
How many SaaS applications do you use frequently? If you're working for a medium-sized company, chances are, that your number of subscriptions ranges from tens to hundreds. So many, that you wouldn't know which tools people on the other end of your org are using, with
When systems grow bigger, we quickly start lacking a degree of oversight that would be comfortable. Our services interact with third-party tools, query databases, send webhook requests, and perform countless other operations. Even for simple projects, analyzing how long certain operations take, or being able to trace individual requests can
An incredibly powerful way of offering a customizable user experience is to allow users to upload media content like images, for profile pictures, or other assets that will be embedded in your product. When you're building a knowledge base for teams, you might want to allow your customers
When you build a service focused around a GraphQL endpoint, you might think of testing strategies that can make use of it. After all, your resolvers will contain large parts of the actual business logic, otherwise, exposing an API wouldn't be useful, would it? Once you reach the
Software is almost always stateful, and that shouldn't really surprise anyone. Rarely do applications not store at least some preferences of the user, whether it is just recently used functionality, keyboard shortcuts, account associations (whether the user signed in, and which account is linked to them), and other
tl;dr: Stop overengineering, think of the first iteration of a feature, build it, ship it, get feedback, and improve it. Building a software product isn't always straightforward. You might have a vision of how you want your product to look like, having thought of well-designed features that
When building user-facing API products and services, validating inputs and enforcing limits is hugely important. Often, this involves repeating similar steps to check given parameters and arguments. Since you can't really trust user-supplied data until it is validated, you're usually required to validate arguments and then
This post deals with the internals of my newly-released navigation library for SwiftUI, Stapel. In my previous post, we took a deep dive into how mobile application navigation usually works. We saw that views are built in layers, pushed onto a virtual stack once a user taps a specific button,
This post deals with the internals of my newly-released navigation library for SwiftUI, Stapel. Today's mobile applications offer a lot of different features, but in most cases, they're built on a simple principle: You're viewing a certain view and by tapping buttons, links, or
Programmatic navigation can be quite hard to build in SwiftUI, requiring you to manage a lot of state internally, figuring out how to nest views correctly so push behaviour works as expected, it's not a lot of fun. I'm excited to announce that I've
The past twelve months have been quite a ride. I remember starting the year helping to shape and rebuild Hygraph into the service that's handling millions of requests per day. With a completely overhauled backend infrastructure, I was in charge of rebuilding the mutation layer, as well as
When developing a software product, you'll end up with multiple environments, for your local development environment, one or many development/staging environments, and a production environment (or multiple depending on your architecture). The same applies to mobile applications. Whether it's for push notifications that use a
Imagine you're building a messaging app where you can invite people with a link. Normally, links are opened in Safari, which doesn't give your users the seamless experience you might hope for. Luckily, you can implement a feature called universal links (often referred to as deep
Sending push notifications (or remote user notifications) to your app's users can help to deliver relevant information in real-time, without your app being in the foreground. Once you enable push notifications for your application by adding the Push Notifications capability, you'll be able to request authorization,
Time is our most valuable resource. It's strictly limited, and we'll never know how much we've got left until it's too late. Ideally, this means we should strive for making the most of that limited resource, spending our time with our families
When developing applications with SwiftUI, you can utilize a wide range of great tools to get instant visual feedback, previews on multiple devices, and even different device types, all in real-time. In my previous post, I emphasized the benefits of building self-contained, reusable, and testable views. When you're
Views are the atomic building blocks of SwiftUI. You combine views to create different components which then add up to screens of your application. Since you most likely want to display dynamic data, your views will have different requirements in terms of data they receive, and the logic they expose.
For a recent project, I needed a list of all countries, their country codes, and an emoji for their flag. Two-letter alphanumeric country codes (following ISO 3166-1) are a common identifier for country names. Unfortunately, to download the official data set as CSV, you'll have to pay \$330
In the ever-changing world of software engineering, keeping track of, not to mention specializing in, a broader range of areas and technologies has become increasingly difficult in the past years. While a lot of web developers will remember the times of uploading their assets to the production server via FTP,
The process of breaking into a new field is always challenging. I've often felt as if I were being held back by an entry barrier that prevents me from progressing, like a lower boundary. Being persistent, repeating, and learning are the only way to break through this barrier.
Your life gets so radically better after you ship something - Patrick McKenzie We've all had that one idea that came up when we least expected it, but from that moment on we couldn't think about anything else. Whether it was for a problem we needed
With today's welcome event, my first semester studying Management & Technology at Technical University of Munich has officially been kicked off. While it is not the first semester to be hit by the ongoing pandemic, studying today is a lot different from what most people are used to,
When working with PostgreSQL databases, pg_dump is a fantastic tool for exporting the current state of a database and restoring it, either using pg_restore or any other database client. You can specify specific schemas and tables to export, include or exclude content, and configure a lot of other
Building systems that make you more productive is a lot like building a software product these days. I've invested a considerable amount of time reading up on and implementing various approaches to making better use of my time, whether it's for learning and studying, or professional
For the past days, I've had the chance to catch up on the fundamentals of set theory, relations, and elementary functions in the context of a maths pre-course at my university. While this will prove itself useful in the months to come, I challenged myself to reach an
With less than two days of work, I completely rebuilt the site you're currently on. With the motivation of creating a faster and more future-proof setup than what I was running before, I dropped features from the old site that I no longer thought of as required and
We use countless software products during the day, whether it's for communicating with our colleagues at work, taking notes, consuming content, writing and deploying code, and all the other tasks we're getting done. Choosing the tools that reduce friction and keep you productive can make the
For millions of people, the past months have radically changed their lives. In my case, one of the most impactful changes was the gradual transition into working fully remotely, or to working from home. I've always cherished the office as a hub to meet my colleagues, communicate and
With codebases growing steadily, so does the time spent waiting for pipelines of builds to finish, type checks to run, and in many development environments, services to be started and stopped. This classic approach to developing TypeScript services has led to much frustration over the years, as the size of
With the recent changes made to the Docker Terms of Service, image pulls from Docker Hub issues by unauthorized clients and users of the free pricing tier will be rate-limited. This essentially means you can perform 100 (or 200) pulls every 6 hours, after which you'll receive rate-limiting
While developing production services in Go over the past year, I've noticed a couple of errors sneak in repeatedly, caused by the same set of pitfalls given by the Go language and ecosystem. Fixing the aforementioned issues was strikingly simple in most of the cases, but debugging tended
When building customer-facing systems, especially in the realm of SaaS businesses, it's important to get a couple design aspects of your system right early on, if you want to plan at scale and grow without unexpected side effects. Scaling out software infrastructure for large customers, especially enterprise clients,
We all have that one domain we want to receive incoming mails on. Whether it's a side project or even the personal domain, being able to forward incoming emails back to our personal inbox can be extremely useful. In most cases, your domain registrar probably offers to forward
GitHub has become the platform where millions of developers get their work done, and as such, one of the biggest targets for building integrations. Whether we're adding Slack notifications for pull requests, connecting our productivity tools to our code, automating deployment and release procedures with CI/CD, or
Browser tests are a great way for teams to quickly write useful end-to-end tests that check the most important pieces of functionality of your app. Depending on the tooling, writing tests can be automated using browser extensions, which enable you to start a recording, browse around your application, and use
When running containerized services in Elastic Container Service (ECS), it's often important to know which environment you're running in. While environment variables can be useful to store deployment-related information, knowing the current cluster, task definition, and revision, or simply the availability zone, can prove vital when
Recently, I was working on a side project which would rely on webhooks from third-party providers, like GitHub, to be picked up by my service exposing a simple HTTP endpoint. Testing this configuration proved to be harder than I initially thought. Of course, I could have just emulated the expected
🎉 As this post is a collaboration between Sentry and me, it was also published to the official Sentry blog, check it out! As the adoption of GraphQL is rising steadily, teams often come across the natural question of how to deal with errors that pass service boundaries and propagate from
When you work on a software project of any kind, you'll come across situations where you spend hours of debugging time, picking everything apart to find why something just doesn't work. In most cases, you'll get down to the source relatively quickly, at least
If you work on a software project, no matter your role, you'll make and a lot of decisions and witness even more being made. Ranging from minor choices between code style A or B to rather impactful ones like where to store data, and why that should be
As products grow, so does the requirement to ship more often, which is desirable as it enables continuous feature delivery in a low-friction scenario. Getting to the point where you can release changes multiples times a day, often even an hour, all without having to worry about breaking production requires
Deciding how and when to ship a new feature can be a sensitive topic. Nobody wants to break production and upset customers. And still, deploying to production tens to hundreds of times a day has become common for a lot of companies. In this post, I want to explore how
As you might have read in this recent post, I spent a considerable amount of time the past month working on setting up and building macOS applications based on Electron as the foundation and React for rendering user interfaces, a popular combination. When starting to build an Electron application, you&
Picking a fitting typeface is one of the most important choices when designing a product. Typefaces, depending on the area of use, will convey brand personality equally if not more than other style decisions, like colors, or spacing. Between sans-serif and serif, handwriting, or monospace, there's a plethora
Cypress has become one of the most popular tools for running reliable browser-based tests across multiple environments, making sure that your web application will behave as expected in production. This surge in user adoption and popularity over the past years is hugely based on high-quality developer documentation, a straightforward API
I spent the last weeks getting started on a minor side project, which I eventually want to use as a simple macOS application. I didn't require any fancy distribution paths through the Mac App Store, but sharing with friends and perhaps making the application available for being downloaded,
Three days ago, the first major version of Deno was released with an accompanying blog post that quickly took the front pages of HackerNews, Twitter, and other communities we tend to spend too much time on. Needless to say, during the past 72 hours, a lot of opinions have been
Writing software tests is one of the most important steps throughout the software development lifecycle. Preventing regressions and validating that business logic works as expected are much-needed guarantees when building a software product. Customer feedback should never be the primary source of learning that something does not work, at least
Over the years plenty of tools to simplify managing your vast infrastructure and deployments emerged. Whether it was Terraform that sought to create declarative representations of cloud resources, or later on Kubernetes with its custom resource definitions (CRDs) connected to the underlying cloud platform, there were many attempts to reduce
Setting up the groundwork for querying your backend APIs should be a quick process, not fiddling around with configuration. Often it can be intimidating to integrate libraries to manage connectivity, caching, and other important features your application is going to benefit from, which is one of the reasons for the
While testing itself is a first-class citizen in Go, features like nested tests and setup and teardown mechanisms are not. Luckily, libraries like testify add capabilities for writing powerful assertions, mocking, and organizing tests in suites. import ( "testing" "github.com/stretchr/testify/suite" ) // We'll
JSON Web Tokens are a popular way of managing authorization and authentication policies for web applications. Sending around a base64-encoded token that can be verified by every service using it, enables uncomplicated (and stateless) application design compared to other mechanisms. In many cases, JWT-based flows will be built around asymmetric
In my last post, I wrote about the benefits of designing your applications in a composable way by the means of being able to substitute commonly-used functions based on randomness with deterministic alternatives for stress-free testing. This is by far not the only use case for providing interchangeable logic to
Over the last few months, I got to write a lot of Go code. In addition to all this code, I wrote a lot of tests. Testing in Go is an absolute breeze, mainly because it's built into the language core and is accompanied by fantastic tooling. If
We all know that testing is one of the most important tasks when writing our software. Creating unit tests of pure functions is straightforward. You set up your test function, assert that the response matches your expectations and call it a day. Testing your request handlers sounds more difficult, or
Sometimes, things go bad. There's no denying that worst cases will occur and request execution might have to be terminated completely. When it comes to your own code, you'll probably know when errors are returned and what this means for your request lifecycle, whether it should
When building your Gatsby site, every page of it is prerendered completely to be shipped to your browser and displayed blazingly fast, compared to parsing and setting up the JavaScript code required to render the React components first, as done in traditional SPAs (e.g. create-react-app). The Gatsby team released
Chances are, that the front page of this site looks different than during your last visit. This is on me, though, I completely ditched the previous design and opted for something more personal, more minimalist, more 2020. Around September of last year, I switched to the globe design you might
Snapshot Testing is a powerful method to build assertions that hold up throughout the development lifecycle. Chances are, that you're already snapshotting parts of your systems, be it network data or results of pure functions. In the Node.js ecosystem, Jest is a popular testing framework, allowing to
I'm thrilled to announce a new project I've been putting hours into the last couple of days! Building data-driven products often means that you want to be able to react to changes as soon as they come in. This means, that you'll expect ways
When designing your application's data layer, you might want to enforce separation of concerns and split tables by the data they hold, for example, moving all optional user data to a profile table and keeping track of the most important details like their name, email address and phone
In addition to the classic INSERT and UPDATE operations, there's another powerful data-modification technique, called upserting. Combining INSERTs for non-existing records and UPDATEs for existing ones, upserts enable various use cases to ensure a document exists and is modified accordingly, if it was created earlier, all while maintaining
Jest is, no doubt, one of the most popular test runners for the JavaScript ecosystem. It contains just the right amount of features to quickly build testing solutions for all project sizes, without thinking about how the tests should be run, or how snapshots should be managed, as we'
In most applications, we create and assert guarantees in our business layer: We check that an account meets certain conditions before running another related query in the database. This leaves us with two problems: If we're querying the same data source, we've made an unnecessary roundtrip
In my previous post, I went over the fundamentals of how the Domain Name System, DNS in short, resolves hostnames to IP addresses, and how the Border Gateway Protocol can be utilized to create a globally-distributed infrastructure to reach users around the world without ever switching hostnames. If you'
Deploying globally-available and distributed applications is tricky and involves a lot of steps. Luckily, we're better off using services already made for this situation, such as serverless platforms or managed DNS with Anycast capabilities. But what does this actually mean and how is today's software deployed
What a year it has been, it's crazy to think back to the first post on this blog, which started it all. Since then, I've published a total of 31 posts, prepared for and survived my final exams, graduated from high school, finally joined the Hygraph
For the longest time, I chose not to set up any metrics for my projects, including my personal site (the one you're currently viewing), since I didn't expect any remarkable metrics to come out of this process whatsoever. Now, that I'd like to see
Testing your Go code in all ways imaginable is really straightforward using the testing package included in the standard library. Very often you'll write assertions to check if the outcome of your project's API (your exported methods and functionalities) equals your expectations, for example, if a
I recently built a job that retrieves a list of files, processes, and batches those to then re-upload said files to a different location. Quickly after deploying the initial version, when running the job on larger targets, it became evident that something was off, essentially making the service unusable. The
The context package and feature is a core part of how most Go applications are built today. Very often, you want to define a timeout, deadline or have the ability to cancel a certain operation and all its invoked functionality from running respectively. When building applications for the web, all
Over the course of the last weeks and months, I've been looking into and comparing a variety of currently available solutions to building and hosting fast and cost-efficient network tunnels, mostly for getting the benefits like a dedicated IP regardless of where you are on the globe, but
Imagine you're building a worker service that will receive a huge list of file metadata to be processed, one by one. Each object represents a file, which you want to upload from one source to the other. Because it won't be a problem, you decide that
Last Friday marked the first-ever edition of southern Germany's only GraphQL conference held yet, GraphQL Day Bodensee. Taking place in beautiful Konstanz, the one-day conference was hosted by Honeypot and Hygraph and offered a variety of amazing talks focused on GraphQL and its ecosystem, ranging from the adoption
Wrapping your head around writing non-blocking, concurrent code can be hard at times, especially when you can't estimate the cost of building your application one way or the other. Using Go's broad spectrum of possibilities to execute synchronously-written and blocking code concurrently with little additional effort
Unlike most JavaScript language features introduced throughout the last years, Generators always felt weird to me from an end-user perspective. Sure, having a function that "can be exited and later re-entered" sounds neat and all, but what would you actually utilize that for in typical web application use
When systems start behaving strangely, inspecting live data becomes a vital part of managing operations of any scale. In addition to actual metrics like request throughput, database operations, and resource usage, real-time service logs are a fundamental piece of information about the health of your infrastructure. In hosted environments like
Imagine the following: You've just completed a polished new feature, upgraded some dependencies, found some code paths that needed refactoring and worked on several other things you're about to release. Unfortunately, your existing commit messages look something like the following: $ git log Commit 453a620131169ed327d8d35ba4952ba5 added cool
It's been an amazing couple of days and I've only now found the time required to jot down some notes, so here's my most important takeaway of everything that happened so far: Without having to think about it for a second time, I'
Last week I had the opportunity to join some of my coworkers on a trip to both GraphQL Conf and Prisma Day in Berlin, the two developer conferences which are most interesting to me personally, and I wasn't let down. Because by the time I'm writing
When you maintain more than a couple of projects, managing dependency upgrades, code quality checks, tests, and publishing releases becomes a chore you'll inevitably face during a project's lifecycle. In addition to this being neither fun, nor a rewarding task, it consumes a lot of time
When deploying your applications to Kubernetes, sometimes you might need to access cluster-internal services without exposing them to the general public. Maybe an API endpoint is behaving strangely, or you need to collect locally-stored metrics: Whatever problem you're encountering, tunneling into your cluster will allow you to send
Achieving consensus in open source projects can be a long-winded process, especially when there's room for numerous implementation directions. To make it clear from the beginning, the process of finding the best solution through consensus in working groups or steering committees is, although tedious, the best way to
While it has been a relatively long time since the last update about my current projects & endeavors, more than a third of the year has already passed and the recent months were packed full of exciting events, to say the least. In this post I'll attempt to
Admittedly, there's a lot of libraries and frameworks to build modern web services in Go, suitable for pretty much every situation you'll ever run into. But sometimes you might just want to use a minimal foundation to build upon, not the full-blown system with all the
If you have ever experienced operational incidents like services seemingly not receiving or handling Pub/Sub messages correctly in production and you're uncertain where the problem originates from, it would be really helpful to observe the stream of messages flowing through the system in real-time. But sometimes, you
Too many times I have found myself at a point of developing a side project, where I had lost all the joy I initially felt while coming up with ideas, drafts, designs and potentially even prototypes — just because too much time had passed since the first steps. And that'
I'm glad to announce the release of yet another command-line tool to make your life a little easier - at least if you're one of the few people that actively use GitHub's status feature: Let's get a round of applause for ghstatus,
I initially planned on writing this post to be about benchmarking and comparing implementations of GraphQL libraries and servers in Go vs. the popular JavaScript & Node.js alternatives like Apollo Server, etc. After delving into the Go ecosystem however, I've found myself switching between a couple of
Welcome back to the short series about getting started with Kubernetes, the practical way! If you haven't read the first post on provisioning a cluster and haven't set up your first cluster yet, please do that first and come back here. If you're running
Welcome to the first post of a series covering the basics of deploying and using Kubernetes! For the first post, we'll look into provisioning a new cluster to use for the following guides. A running cluster is an essential part of your infrastructure, every application will be eventually
A few days ago, I published my introductory post on a freshly-released tool called compose-deploy, which can be used to deploy your Docker Compose application to a group of deployment targets using nothing more than ssh and built-in Docker (and Docker Compose) features. Since then, I have tried to think
When developing dockerized applications, you might stumble upon the sheer difficulty and annoyance of simply deploying your Compose file along with built service images. If you're not using a full cloud setup and instead want to deploy to a small number of machines, you're left with
This article is the first part of a planned series of exploration into the Kubernetes ecosystem and more specifically its tooling projects. Since I'm very interested in the development of all things containers & orchestration, I thought it was a neat idea to share my impressions and provide
After doing some cleanup on my projects list, I found a nearly-forgotten tool that I wrote a few months ago, and with some polishing and overhaul done, I'm happy to present to the world: aqueduct. To put it simply, it's a proxy service for GraphQL applications,
After releasing the post about tracing basics with an example of setting up tracing with a GraphQL service, I thought of a solution to make the development of tracing features for this kind of services even easier - the result of that effort is called graphql-middleware-jaeger. The simple functionality of
Tracing has emerged as one of the most widely-used techniques to monitor the performance and health of your services and applications, from development to production. Due to this heavy usage, a large amount of tooling is published and improved constantly, focusing on features related to distributed systems and recent industry
👋 Hey there! As you might have noticed, everything on this site looks different from a week ago. That's mostly because I fully revamped my portfolio, using newer, faster and better tech, as well as a completely new design language. Powered by Gatsby, this site with all its blog