The Software Architects' Newsletter
February 2026
View in browser

Welcome to the InfoQ Software Architects' Newsletter! We bring you essential news and experience on emerging patterns and technologies from industry peers each month.

This month, we focus on "Architecture Through Different Lenses". Technologies, patterns, and practices from this topic span the entire "diffusion of innovation" graph in last year's "InfoQ Software Architecture and Design Trends Report".

This newsletter explores software architecture through multiple lenses, including technical, organizational, human, economic, and operational. From Conway's Law and socio-technical systems to developer experience, governance, and AI-augmented design, it examines how different perspectives shape architectural decisions and long-term outcomes. Understanding these lenses helps architects reason more clearly about trade-offs, constraints, and changes at scale.

News

OpenAI Scales Single Primary PostgreSQL Instance to Millions of Queries per Second for ChatGPT

OpenAI outlined how it scaled PostgreSQL to handle millions of queries per second for ChatGPT and its API platform, serving hundreds of millions of users globally. The effort highlights how far a single primary PostgreSQL instance can be pushed before write-intensive workloads require additional distributed solutions, emphasizing design trade-offs and operational guardrails needed for a low-latency, globally available service.

WhatsApp Deploys Rust-Based Media Parser to Block Malware on Three Billion Devices

WhatsApp's engineering team has rewritten its media handling library in Rust, reducing the codebase from one hundred sixty thousand lines of C++ to ninety thousand while adding memory safety protections. The library runs on billions of devices, including Android phones, iPhones, desktops, watches, and web browsers, making it one of the largest client-side deployments of Rust code to date.

The effort traces back to 2015's Stagefright vulnerability, which showed how attackers could hide malware inside seemingly innocent image or video files. Those malicious files targeted bugs in Android's media libraries, and apps like WhatsApp couldn't patch the underlying OS. At the time, WhatsApp had a C++ library called "wamedia" that checked MP4 files for conformance issues before sending them.

LinkedIn Re-Architects Service Discovery: Replacing Zookeeper with Kafka and xDS at Scale

In a recent LinkedIn Engineering Blog post, Bohan Yang describes the project to upgrade the company's legacy ZooKeeper-based service discovery platform. Facing imminent capacity limits with thousands of microservices, LinkedIn needed a more scalable architecture. The new system leverages Apache Kafka for writes and the xDS protocol for reads, enabling eventual consistency and allowing non-Java clients to participate as first-class citizens. To ensure stability, the team implemented a "dual mode" strategy that allowed for an incremental, zero-downtime migration.

Uber Moves from Static Limits to Priority-Aware Load Control for Distributed Storage

Uber engineers have described how they evolved their distributed storage platform from static rate limiting to a priority-aware load management system to protect their in-house databases. The change addressed the limitations of QPS-based rate limiting in large, stateful, multi-tenant systems, which did not reflect actual load, handle noisy neighbors, or protect tail latency.

The design protects Docstore and Schemaless, which are built on MySQL and serve traffic through thousands of microservices, supporting over one hundred seventy million monthly active users, including riders, Uber Eats users, drivers, and couriers. By prioritizing critical traffic and adapting dynamically to system conditions, the system prevents cascading overloads and maintains performance at scale.

Working with Code Assistants: the Skeleton Architecture

The Skeleton Architecture is an approach to structuring systems for safe, maintainable AI-assisted development. It separates stable, human-defined "skeleton" components (interfaces, workflows, and guardrails) from AI-generated "tissue" that implements business logic. This approach reduces AI context requirements while ensuring consistency in security, observability, and performance.

By enforcing patterns such as dependency inversion and template methods, architects retain control over system behaviour while allowing AI to accelerate implementation. The model shifts engineers toward defining constraints, information flow, and non-functional requirements. Ultimately, Skeleton Architecture enables teams to leverage AI productivity gains without sacrificing architectural integrity or long-term maintainability.

On a related topic, Shane Hastie recently spoke to Ben Greene on the InfoQ Engineering Culture podcast about embracing AI in software engineering, expanding beyond pure technical skills to understand business context, and prioritizing human empathy in increasingly automated systems.

Case Study

You’ve Generated Your MVP Using AI. What Does That Mean for Your Software Architecture?

AI can rapidly generate a minimum viable product (MVP), but using AI shifts the role and focus of software architecture rather than eliminating it.

AI-generated code acts largely as a “black box”, making implicit architectural decisions that teams may not fully understand, control, or maintain over time. This approach introduces risks around technical debt, sustainability, and integration with existing systems, particularly when quality attribute requirements (QARs) such as scalability, security, and performance must be met.

As a result, architecture becomes more empirical. Instead of designing systems primarily up front, teams must focus on validating AI-generated architectures through experimentation and architectural testing, including performance, usability, resilience, and security testing. These validation activities help determine whether the system satisfies business and technical requirements.

Architectural decision-making remains critical, but it should shift toward clearly articulating trade-offs and constraints in prompts so AI can generate appropriate solutions.

Architects must also consider long-term maintainability, because AI-generated code may be difficult to evolve or repair. Ultimately, AI accelerates implementation, but increases the importance of defining architectural qualities, validating outcomes empirically, and ensuring systems remain sustainable as AI tools evolve.

In a related InfoQ video podcast, Shweta Vohra and Grady Booch recently explored a principled view of how architecture must evolve when machines begin writing code alongside humans.

This content is a short summary of a recent InfoQ article by Pierre Pureur and Kurt Bittner, "You've Generated Your MVP Using AI. What Does That Mean for Your Software Architecture?"

To get notifications when InfoQ publishes content on these topics, follow "Architecture and Design", "Sociotechnical Architecture", and "Culture and Methods" on InfoQ.

Missed a newsletter? You can find all of the previous issues on InfoQ.

Upcoming Events