/Architecture

Tumblr Shares Database Migration Strategy With 60+ Billion Rows

tl;dr: The article delves into Tumblr's database migration strategy. With a massive MySQL database spanning 21 terabytes and 60+ billion rows, Tumblr sought a migration approach that minimized user impact. Initially considering a brute force method, they later adopted the CQRS pattern, which separates database read and write operations. To combat latency issues, Tumblr introduced a database proxy in the local data center, which maintained persistent connections to the remote leader and allowed for connection pooling. This strategy ensured minimal user disruption during migration.

featured in #447


In Defense Of Simple Architectures

- Dan Luu tl;dr: Dan discusses the effectiveness of simple architectures in software development, using Wave, a $1.7B company, as an example. Wave's architecture is a Python monolith on top of Postgres, allowing engineers to focus on delivering value to users. The article emphasizes that simple architectures can be created more cheaply and easily than complex ones, even for high-traffic apps. Despite the trend towards complex, microservice-based architectures, Dan argues for the "unreasonable effectiveness" of monoliths, detailing Wave's choices, mistakes, and areas of unavoidable complexity. Simplicity in architecture can lead to success, allowing companies to allocate complexity where it benefits the business.

featured in #439


Nice To Meet You, MondayDB Architecture

- Liran Brimer tl;dr: The article discusses the development of "mondayDB," an in-house data engine at monday.com. It addresses challenges in handling board data efficiently, explains the use of columnar storage and lambda architecture, and the separation of storage from computation. The system significantly improves board loading times and scalability. Future plans include optimizations and exploring new technologies like DuckDB and Rust.

featured in #435


Emerging Architectures For LLM Applications

- Matt Bornstein Rajko Radovanovic tl;dr: "In this post, we’re sharing a reference architecture for the emerging LLM app stack. It shows the most common systems, tools, and design patterns we’ve seen used by AI startups and sophisticated tech companies. This stack is still very early and may change substantially as the underlying technology advances, but we hope it will be a useful reference for developers working with LLMs now.”

featured in #425


Linking Modular Architecture To Development Teams

- Matthew Foster tl;dr: “This article charts the journey of an enterprise who set out to shift their architecture to a more modular one in order to ease their growing pains. They found that modularity is a multifaceted solution that extends beyond architecture, into business lines of communication, team topologies and effective developer experience. By paying close attention to these factors, the enterprise was able to achieve significant uplifts in the delivery performance of their mobile applications.”

featured in #424


Migrating Critical Traffic At Scale With No Downtime — Part 2

tl;dr: “Replay traffic testing gives us the initial foundation of validation, but as our migration process unfolds, we are met with the need for a carefully controlled migration process. A process that doesn’t just minimize risk, but also facilitates a continuous evaluation of the rollout’s impact. This blog post will delve into the techniques leveraged at Netflix to introduce these changes to production.”

featured in #422


How eBay's New Search Feature Was Inspired By Window Shopping

tl;dr: "The technical challenge we faced was developing a system that could understand and interpret the visual characteristics of images to provide accurate search results. By leveraging advanced computer vision algorithms and machine learning techniques, we were able to bridge the gap between textual queries and visual preferences, revolutionizing the way users discover and explore items on eBay."

featured in #421


The Growing Pains Of Database Architecture

- Tim Liang tl;dr: “In 2020, Figma’s infrastructure hit some growing pains due to a combination of new features, preparing to launch a second product, and more users - database traffic grows approximately 3x annually.” Tim discusses the infrastructure changes the team implemented.

featured in #420


Architecture Principles: An Approach To Effective Decision Making In Software Architecture

- Patrick Roos tl;dr: “Are you a software architect and often find it difficult to make architecture decisions in your team? This article shows you how to use architecture principles to make effective decisions in your team.”

featured in #416


The Simple Joys Of Scaling Up

- Jordan Tigani tl;dr: “After such a dramatic increase in hardware capability, we should ask ourselves, “Do the conditions that drove our scaling challenges in 2003 still exist?” After all, we’ve made our systems far more complex and added a lot of overhead. Is it all still necessary? If you can do the job on a single machine, isn’t that going to be a better alternative?” This post digs into why scale-out became so dominant, take a look at whether those rationales still hold, and then explore some advantages of such architecture.

featured in #416