# software-architecture

Published articles for software-architecture.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## How to Migrate a Legacy Monolith Incrementally Without a Big-Bang Rewrite

DevFeed: [How to Migrate a Legacy Monolith Incrementally Without a Big-Bang Rewrite](<https://devfeed.tech/articles/how-to-migrate-a-legacy-monolith-incrementally-without-a-big-bang-rewrite-42754.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/migrate-legacy-monolith-incrementally/>)

Author: Hugo Teijiz

Published: 2026-09-17T23:27:03Z

Content type: tutorial

Language: en

Sources: [freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [Legacy Modernization](<https://devfeed.tech/topics/legacy-modernization.md>), [migration](<https://devfeed.tech/topics/migration.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [API](<https://devfeed.tech/topics/api.md>), [service](<https://devfeed.tech/topics/service.md>), [Dependency injection](<https://devfeed.tech/topics/dependency-injection.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [integration-testing](<https://devfeed.tech/tags/integration-testing.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [migrate](<https://devfeed.tech/tags/migrate.md>), [migration](<https://devfeed.tech/tags/migration.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [routing](<https://devfeed.tech/tags/routing.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

A tutorial on migrating a legacy monolith incrementally by moving one business capability at a time. It covers characterization tests, boundaries between legacy and new code, parallel implementations, progressive traffic, observability, rollback paths, data ownership, and removing migrated behavior.

### Source excerpt

Large legacy migrations often fail long before the final cutover. The failure usually starts when the migration is framed as a single event. Move the application. Move the database. Move all the users

## How to Use Differential Testing During a Legacy Migration

DevFeed: [How to Use Differential Testing During a Legacy Migration](<https://devfeed.tech/articles/how-to-use-differential-testing-during-a-legacy-migration-20762.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/differential-testing-legacy-migration/>)

Author: Hugo Teijiz

Published: 2026-09-14T16:25:50Z

Content type: tutorial

Language: en

Sources: [freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [migration](<https://devfeed.tech/topics/migration.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>), [API](<https://devfeed.tech/topics/api.md>), [observability](<https://devfeed.tech/topics/observability.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [code](<https://devfeed.tech/tags/code.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [integration](<https://devfeed.tech/tags/integration.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [legacy-modernization](<https://devfeed.tech/tags/legacy-modernization.md>), [migration](<https://devfeed.tech/tags/migration.md>), [modernization](<https://devfeed.tech/tags/modernization.md>), [observability](<https://devfeed.tech/tags/observability.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>), [testing](<https://devfeed.tech/tags/testing.md>), [tests](<https://devfeed.tech/tags/tests.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>), [typescript](<https://devfeed.tech/tags/typescript.md>)

### AI overview

This tutorial explains how to use differential testing during a legacy migration by running old and new implementations with identical inputs and comparing their behavior. It covers equivalence rules, output normalization, nondeterministic values, errors, side effects, automated testing, mismatch analysis, production shadow traffic, and using AI to classify divergences without allowing it to determine correctness.

### Source excerpt

The most dangerous moment in a legacy migration isn't necessarily when you start writing the new implementation. It's when the new implementation looks finished. The code compiles, the tests pass, the

## Kotlin Explicit Backing Fields: Encapsulation Tradeoffs and Downcasting Risks

DevFeed: [Kotlin Explicit Backing Fields: Encapsulation Tradeoffs and Downcasting Risks](<https://devfeed.tech/articles/the-downcast-trap-in-kotlin-s-explicit-backing-fields-22951.md>)

Original publisher: [Read original article](<https://proandroiddev.com/the-downcast-trap-in-kotlins-explicit-backing-fields-626ef0d66e50?source=rss----c72404660798---4>)

Author: Ehab Elwan

Published: 2026-09-13T05:31:32Z

Content type: opinion

Language: en

Sources: [ProAndroidDev - Medium](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Code](<https://devfeed.tech/topics/code.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [article](<https://devfeed.tech/tags/article.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [memory](<https://devfeed.tech/tags/memory.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [stateflow](<https://devfeed.tech/tags/stateflow.md>)

### AI overview

This article compares Kotlin's traditional private mutable property plus public read-only wrapper with explicit backing fields. It explains that explicit backing fields can avoid an extra wrapper allocation, but because the underlying object remains mutable, an external downcast may bypass the intended read-only restriction and mutate internal state.

### Source excerpt

Why eliminating the double-property boilerplate changes how we protect our architecture Image generated by AIDisclosure: This article was drafted by me and refined with the help of AI tools. If you have written Kotlin in the last few years, you are intimately familiar with the double-property boilerplate. Whether in Android ViewModels or general state holders, maintaining a private mutable property alongside a public read-only property is a chore we have all accepted in the name of strict encapsulation to prevent our internal state from being hijacked by outside classes. It makes the code significantly cleaner (and slightly more memory efficient). However, it fundamentally changes how we protect our state, moving from a physical object boundary to a simple type restriction. Let's look at the tradeoff. The Old Way: Wrapper Protection For years, the standard approach to encapsulating state has looked like this: class OldViewModel { // 1. The private mutable state private val _uiState = MutableStateFlow(UiState()) // 2. The public read-only state val uiState: StateFlow<UiState> = _uiState.asStateFlow() } This is tedious to write, but it provides a strict architectural guarantee. When you call .asStateFlow(), Kotlin does not just change the type; it creates a brand new wrapper object in memory (ReadonlyStateFlow). While this physical barrier is fantastic for safety, it does mean you are incurring a minor memory allocation overhead by creating a secondary wrapper object for every exposed state. The New Way: Upcasting Explicit Backing Fields allow you to merge these two properties into one concise declaration, bypassing that extra memory allocation entirely: class NewViewModel { val uiState: StateFlow<UiState> field = MutableStateFlow(UiState()) } Inside your class, the Kotlin compiler smart-casts the field so you can mutate it internally. Outside the class, the compiler restricts callers to the read-only StateFlow interface. It looks incredibly clean and saves an allocat

## The Android Startup Pattern: A Lifecycle-Aware, Multi-Module Approach

DevFeed: [The Android Startup Pattern: A Lifecycle-Aware, Multi-Module Approach](<https://devfeed.tech/articles/the-android-startup-pattern-a-lifecycle-aware-multi-module-approach-22950.md>)

Original publisher: [Read original article](<https://proandroiddev.com/the-android-startup-pattern-a-lifecycle-aware-multi-module-approach-d0f73e367a62?source=rss----c72404660798---4>)

Author: Ehab Elwan

Published: 2026-09-13T05:31:09Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev - Medium](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [Framework](<https://devfeed.tech/topics/framework.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [app-startup](<https://devfeed.tech/tags/app-startup.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [framework](<https://devfeed.tech/tags/framework.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [mobile-architecture](<https://devfeed.tech/tags/mobile-architecture.md>), [module](<https://devfeed.tech/tags/module.md>), [privacy](<https://devfeed.tech/tags/privacy.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

This tutorial presents a lifecycle-aware, dependency-injection-driven startup pattern for modular Android applications. It contrasts a centralized startup anti-pattern with Jetpack App Startup and discusses process lifecycles, testability, and delaying tracking SDK initialization until privacy consent is evaluated.

### Source excerpt

A Clean, DI-Driven Architecture for Managing Cold Starts, Background Wakeups, and Privacy Compliance in Modern Android Apps Image generated by AIDisclosure: This article was drafted by me and refined with the help of AI tools. Every growing Android project eventually spawns a two-headed "God Class." On one side, your Application class becomes a dumping ground for global infrastructure--third-party SDKs, crash reporters, and tracking tools. On the other side, your main entry point (typically the MainViewModel) gets choked with UI-blocking startup logic. It usually looks something like this: The Anti-Pattern: The Two-Headed God Class class MyApplication : Application() { override fun onCreate() { super.onCreate() // The framework dumping ground CrashReportingSDK.getInstance().setCollectionEnabled(true) HeavyUiSDK.initialize(context = this, ...) AnalyticsSDK.initialize(this, "API_KEY") // ... 50 more lines of spaghetti } }class MainViewModel : ViewModel() { init { // The UI-blocking dumping ground updateRemoteConfigs() checkUserSessionToken() processPendingDeepLinks() prefetchHomeFeedData() // ... UI cannot render until this finishes } } Splitting initialization across these two files creates major problems: It breaks the Single Responsibility Principle: The app's entry points are forced to orchestrate the inner workings of every single feature, tightly coupling your modules. It ignores process lifecycles: Application tasks run indiscriminately on every silent background wakeup, while MainViewModel tasks fail to re-trigger when the app returns to the foreground. It destroys testability: Hardcoding SDK initializations directly into your entry points makes it incredibly difficult to write isolated unit tests without complicated mocking setups. It complicates privacy compliance: A centralized dumping ground makes it extremely difficult to dynamically suspend tracking SDKs until user consent under global privacy regulations (such as GDPR, CCPA, and CPRA) is explicitly grant

## Thursday Notes on Architecture Trade-offs and High-Performing Teams

DevFeed: [Thursday Notes on Architecture Trade-offs and High-Performing Teams](<https://devfeed.tech/articles/hello-to-my-thursday-notes-38687.md>)

Original publisher: [Read original article](<https://newsletter.techworld-with-milan.com/p/hello-to-my-thursday-notes>)

Author: Dr Milan Milanović

Published: 2026-09-10T15:00:57Z

Content type: opinion

Language: en

Sources: [Tech World With Milan Newsletter](<https://devfeed.tech/sources/tech-world-with-milan-newsletter.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [fault-tolerance](<https://devfeed.tech/tags/fault-tolerance.md>), [security](<https://devfeed.tech/tags/security.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [split](<https://devfeed.tech/tags/split.md>), [team-topologies](<https://devfeed.tech/tags/team-topologies.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

This issue of Thursday Notes discusses architecture as a search for acceptable trade-offs, including reasons to split or merge services. It also explains how teams cycle through forming, storming, norming, and performing, and how leadership should adapt to each stage.

### Source excerpt

Hey, Milan here.

## How Poke Gives Every User Their Own Database, Without Them Ever Knowing

DevFeed: [How Poke Gives Every User Their Own Database, Without Them Ever Knowing](<https://devfeed.tech/articles/how-poke-gives-every-user-their-own-database-without-them-ever-knowing-5961.md>)

Original publisher: [Read original article](<https://turso.tech/blog/how-poke-gives-every-user-their-own-database>)

Author: Jeff Olson

Published: 2026-08-20T00:00:00Z

Content type: article

Language: en

Sources: [Turso Blog](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [Turso](<https://devfeed.tech/topics/turso.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Security](<https://devfeed.tech/topics/security.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [cpu](<https://devfeed.tech/topics/cpu.md>)

Tags: [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [code](<https://devfeed.tech/tags/code.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [performance](<https://devfeed.tech/tags/performance.md>), [security](<https://devfeed.tech/tags/security.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

Poke provisions a separate Turso database for each website generated by its iMessage personal assistant. The per-user isolation helps contain inefficient SQL, unexpected traffic, security vulnerabilities, and associated performance or data-leakage risks while keeping costs manageable for low-traffic sites.

### Source excerpt

How Poke's iMessage assistant provisions a Turso database for every website it builds, giving each user full isolation without them ever noticing.

## Multi-tenancy at Scale: How to Give Every User Their Own Database

DevFeed: [Multi-tenancy at Scale: How to Give Every User Their Own Database](<https://devfeed.tech/articles/multi-tenancy-at-scale-how-to-give-every-user-their-own-database-6006.md>)

Original publisher: [Read original article](<https://turso.tech/blog/multi-tenancy-at-scale>)

Author: Jeff Olson

Published: 2026-08-17T00:00:00Z

Content type: article

Language: en

Sources: [Turso Blog](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [Multi-tenancy](<https://devfeed.tech/topics/multi-tenancy.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Turso](<https://devfeed.tech/topics/turso.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [multi-tenancy](<https://devfeed.tech/tags/multi-tenancy.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [platform-api](<https://devfeed.tech/tags/platform-api.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [saas](<https://devfeed.tech/tags/saas.md>), [scale](<https://devfeed.tech/tags/scale.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

This article argues that database-per-tenant architecture becomes practical at scale when each tenant database is a SQLite file rather than a continuously running PostgreSQL or MySQL server process. It contrasts the cost, connection-pooling, and backup challenges of server-based databases with SQLite's low-cost, file-based model, using Turso as the relevant platform context.

### Source excerpt

The warnings against giving every tenant their own database assume a database is a server process. When a database is a file, the tradeoffs look completely different.

## Flexible Authentication: Reimagining authentication for millions of users at Airbnb

DevFeed: [Flexible Authentication: Reimagining authentication for millions of users at Airbnb](<https://devfeed.tech/articles/flexible-authentication-reimagining-authentication-for-millions-of-users-at-airbnb-1216.md>)

Original publisher: [Read original article](<https://medium.com/airbnb-engineering/flexible-authentication-reimagining-authentication-for-millions-of-users-at-airbnb-3a8a4c917137?source=rss----53c7c27702d5---4>)

Author: Jose Santos

Published: 2026-08-12T17:01:04Z

Content type: article

Language: en

Sources: [The Airbnb Tech Blog - Medium](<https://devfeed.tech/sources/the-airbnb-tech-blog-medium.md>)

Topics: [Authentication](<https://devfeed.tech/topics/authentication.md>), [App](<https://devfeed.tech/topics/app.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [authentication](<https://devfeed.tech/tags/authentication.md>), [blog](<https://devfeed.tech/tags/blog.md>), [brazil](<https://devfeed.tech/tags/brazil.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [identity](<https://devfeed.tech/tags/identity.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [product-intuition](<https://devfeed.tech/tags/product-intuition.md>), [revenue](<https://devfeed.tech/tags/revenue.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [technology](<https://devfeed.tech/tags/technology.md>), [whatsapp](<https://devfeed.tech/tags/whatsapp.md>)

### AI overview

Airbnb describes Flexible Authentication, a redesign of login and signup for users with varied session patterns, devices, and login methods. Its central model identifies the user first and then selects the verification challenge best suited to the person and context, such as WhatsApp OTP or a regional identity provider.

### Source excerpt

Rebuilding login and signup surfaced product insights, not just technical challenges. Here's how we designed Flexible Authentication at the intersection of product intuition and technical architecture. By: Jose Santos, Mike Barry For Airbnb, logins at irregular intervals are normal. A guest books a trip in January and may not open the app again until summer. A host checks back only when a reservation comes in, and may be busy with other activities when it does. For a two-sided marketplace where a failed login means a lost booking, and lost revenue for both the guest and the host, long gaps between sessions are a structural challenge, not an edge case. Our authentication system had grown organically over a decade, adding new login methods like Social Login, Email OTP, and Phone over time. We recognized that our users have diverse needs: many, such as hosts, use Airbnb daily, while others visit less frequently, when they are planning trips or traveling. To provide a seamless experience, we needed to ensure we were doing a great job supporting all of these usage patterns, helping users pick up exactly where they left off, regardless of how much time had passed or which device they were using. In this blog post, we'll walk through how we rebuilt Airbnb's authentication flows using a new paradigm we call Flexible Authentication, and how each architectural decision was guided by insights into the user's experience. Identify first then Challenge The 'Identify first then Challenge' model was the product insight that reframed the project. Our old system treated authentication as a single question: can this person prove who they are? The real question is more nuanced: given the multiple aspects of the user session, what's the easiest way for them to verify it? A traveler in Brazil who registered with a phone number is better served by a WhatsApp one-time password (OTP) than by SMS, since WhatsApp penetration far exceeds SMS in this market. A returning host in South Korea is b

## Containing Locally Running AI Agents with Layered Security Controls

DevFeed: [Containing Locally Running AI Agents with Layered Security Controls](<https://devfeed.tech/articles/agent-lockdown-37513.md>)

Original publisher: [Read original article](<https://blog.apartment304.com/agent-lockdown/>)

Author: Spencer Reeves

Published: 2026-08-10T18:00:00Z

Content type: tutorial

Language: en

Sources: [Apartment 304](<https://devfeed.tech/sources/apartment-304.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Security](<https://devfeed.tech/topics/security.md>), [Containers](<https://devfeed.tech/topics/containers.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>), [macOS](<https://devfeed.tech/topics/macos.md>), [npm](<https://devfeed.tech/topics/npm.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [apartment-304](<https://devfeed.tech/tags/apartment-304.md>), [apple](<https://devfeed.tech/tags/apple.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [custom-software-solutions](<https://devfeed.tech/tags/custom-software-solutions.md>), [devops](<https://devfeed.tech/tags/devops.md>), [devops-engineer](<https://devfeed.tech/tags/devops-engineer.md>), [macos](<https://devfeed.tech/tags/macos.md>), [networking](<https://devfeed.tech/tags/networking.md>), [npm](<https://devfeed.tech/tags/npm.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [sandboxing](<https://devfeed.tech/tags/sandboxing.md>), [security](<https://devfeed.tech/tags/security.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineer](<https://devfeed.tech/tags/software-engineer.md>)

### AI overview

This article presents a layered security approach for running AI agents locally. It focuses on sandboxing the agent, restricting internet access, and protecting secrets and environment files, with container isolation as the foundation.

### Source excerpt

Running an agent locally gives it a foothold on your machine -- here's how we keep it contained.

## CTO.new Coordinates Tens of Thousands of AI Agents with a Database per Project on Turso

DevFeed: [CTO.new Coordinates Tens of Thousands of AI Agents with a Database per Project on Turso](<https://devfeed.tech/articles/cto-new-coordinates-tens-of-thousands-of-ai-agents-with-a-database-per-project-on-turso-5922.md>)

Original publisher: [Read original article](<https://turso.tech/blog/cto-new-coordinates-tens-of-thousands-of-ai-agents>)

Author: Glauber Costa

Published: 2026-08-06T00:00:00Z

Content type: article

Language: en

Sources: [Turso Blog](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [AI Bots](<https://devfeed.tech/topics/ai-bots.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [AI, ML & Data Engineering](<https://devfeed.tech/topics/ai-ml-data-engineering.md>)

Tags: [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [autonomous-agents](<https://devfeed.tech/tags/autonomous-agents.md>), [coding](<https://devfeed.tech/tags/coding.md>), [database](<https://devfeed.tech/tags/database.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [security](<https://devfeed.tech/tags/security.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [turso](<https://devfeed.tech/tags/turso.md>), [vibe-coding](<https://devfeed.tech/tags/vibe-coding.md>)

### AI overview

CTO.new uses a dedicated Turso database for each AI-agent project to coordinate workloads at scale. The article describes lower database costs compared with its earlier Supabase setup and the platform's return to Turso for agent infrastructure management.

### Source excerpt

CTO.new gives every team of AI agents its own Turso database as a coordination layer, running tens of thousands of databases on a $500 per month plan.

## Building a Multi-Theme Design System in Figma

DevFeed: [Building a Multi-Theme Design System in Figma](<https://devfeed.tech/articles/building-a-multi-theme-design-system-in-figma-37516.md>)

Original publisher: [Read original article](<https://blog.apartment304.com/figma-design-system/>)

Author: Jacqueline Rhoda

Published: 2026-07-27T18:53:49Z

Content type: tutorial

Language: en

Sources: [Apartment 304](<https://devfeed.tech/sources/apartment-304.md>)

Topics: [Design system](<https://devfeed.tech/topics/design-system.md>), [Figma](<https://devfeed.tech/topics/figma.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [color](<https://devfeed.tech/topics/color.md>)

Tags: [apartment-304](<https://devfeed.tech/tags/apartment-304.md>), [color](<https://devfeed.tech/tags/color.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [custom-software-solutions](<https://devfeed.tech/tags/custom-software-solutions.md>), [design](<https://devfeed.tech/tags/design.md>), [design-system](<https://devfeed.tech/tags/design-system.md>), [design-systems](<https://devfeed.tech/tags/design-systems.md>), [devops](<https://devfeed.tech/tags/devops.md>), [devops-engineer](<https://devfeed.tech/tags/devops-engineer.md>), [figma](<https://devfeed.tech/tags/figma.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineer](<https://devfeed.tech/tags/software-engineer.md>), [tokens](<https://devfeed.tech/tags/tokens.md>)

### AI overview

This tutorial explains how to build a multi-theme design system in Figma. It describes keeping components, layouts, and patterns consistent while adapting brand identity and visual styles through variables, styles, and semantic color tokens.

### Source excerpt

Build flexible Figma design systems that scale across brands and customers.

## ESP-GMF v1.0: General Multimedia Framework, First Official Release

DevFeed: [ESP-GMF v1.0: General Multimedia Framework, First Official Release](<https://devfeed.tech/articles/esp-gmf-v1-0-general-multimedia-framework-first-official-release-13782.md>)

Original publisher: [Read original article](<https://developer.espressif.com/blog/2026/07/esp-gmf-v1-0-release/>)

Author: John Lee

Published: 2026-07-21T00:00:00Z

Content type: release

Language: en

Sources: [Blog on Developer Portal](<https://devfeed.tech/sources/blog-on-developer-portal.md>)

Topics: [Frameworks](<https://devfeed.tech/topics/frameworks.md>), [Espressif](<https://devfeed.tech/topics/espressif.md>), [releases](<https://devfeed.tech/topics/releases.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Playback](<https://devfeed.tech/topics/playback.md>), [Image processing](<https://devfeed.tech/topics/image-processing.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [audio](<https://devfeed.tech/tags/audio.md>), [blog](<https://devfeed.tech/tags/blog.md>), [esp](<https://devfeed.tech/tags/esp.md>), [esp-gmf](<https://devfeed.tech/tags/esp-gmf.md>), [espressif](<https://devfeed.tech/tags/espressif.md>), [image-processing](<https://devfeed.tech/tags/image-processing.md>), [multimedia](<https://devfeed.tech/tags/multimedia.md>), [playback](<https://devfeed.tech/tags/playback.md>), [release](<https://devfeed.tech/tags/release.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

Espressif announces ESP-GMF v1.0, the first official release of its unified multimedia framework for developing audio, video, and AI multimedia applications on Espressif chips. The release provides a stable API, a modular component architecture, broader media and hardware support, and improved code reuse. It also introduces the ESP Multimedia Core as a shared foundation for multimedia components.

### Source excerpt

ESP-GMF v1.0 is the first official release of Espressif's General Multimedia Framework, a lightweight, unified framework for building audio, video, and AI multimedia applications on Espressif chips. This post introduces the release, walks through what is new for each component area, and lists the full v1.0 component set.

## Building AI Agent Databases: A Complete Guide to Database-per-Agent Architecture

DevFeed: [Building AI Agent Databases: A Complete Guide to Database-per-Agent Architecture](<https://devfeed.tech/articles/building-ai-agent-databases-a-complete-guide-to-database-per-agent-architecture-5873.md>)

Original publisher: [Read original article](<https://turso.tech/blog/a-complete-guide-to-database-per-agent-architecture>)

Author: Jeff Olson

Published: 2026-07-20T00:00:00Z

Content type: tutorial

Language: en

Sources: [Turso Blog](<https://devfeed.tech/sources/turso-blog.md>)

Topics: [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [Turso](<https://devfeed.tech/topics/turso.md>), [Database](<https://devfeed.tech/topics/database.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Multi-tenancy](<https://devfeed.tech/topics/multi-tenancy.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [building](<https://devfeed.tech/tags/building.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [multi-tenancy](<https://devfeed.tech/tags/multi-tenancy.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [turso](<https://devfeed.tech/tags/turso.md>)

### AI overview

This guide explains why giving each AI agent its own dedicated database can be preferable to shared multi-tenant designs. It presents Turso as a lightweight option for creating isolated databases whose storage, lifecycle, and cleanup can be managed independently.

### Source excerpt

Most database scaling advice breaks when you're dealing with AI agents. Here's why giving each agent its own database works, and four patterns for building it on Turso.

## Let Koin Shape your Application Architecture

DevFeed: [Let Koin Shape your Application Architecture](<https://devfeed.tech/articles/let-koin-shape-your-application-architecture-22974.md>)

Original publisher: [Read original article](<https://blog.insert-koin.io/let-koin-shape-your-application-architecture-9cd60b1e02b0?source=rss----925561f2ecdf---4>)

Author: Gabriel Bronzatti Moro

Published: 2026-07-06T12:01:01Z

Content type: tutorial

Language: en

Sources: [Koin developers - Medium](<https://devfeed.tech/sources/koin-developers-medium.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Software](<https://devfeed.tech/topics/software.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [clean-architecture](<https://devfeed.tech/tags/clean-architecture.md>), [developer](<https://devfeed.tech/tags/developer.md>), [koin](<https://devfeed.tech/tags/koin.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [software](<https://devfeed.tech/tags/software.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-design](<https://devfeed.tech/tags/software-design.md>)

### AI overview

This tutorial explains how Koin can support application architecture based on Clean Architecture and software design practices. It describes using Koin to create and manage object instances, including singleton and factory definitions, with Ktor's HttpClient as an example.

### Source excerpt

Hey, friends! 👋 Today we're going to explore application architecture and how Koin can help us build scalable, maintainable applications by applying the principles of Clean Architecture and other software design best practices. Application architecture is a fundamental skill for every software engineer. A well-designed architecture makes applications easier to understand, test, extend, and maintain as they grow over time. A collection of LEGO towers in various stages of construction -- Unsplash by richard_heFoundation When we think about software architecture, we often picture layered diagrams -- data, domain, and presentation -- along with classes such as use cases, handlers, repositories, and helpers. But how do all these components work together? How do we establish a reliable communication protocol between them? Architecture is more than just organizing classes into packages. It's about defining how objects communicate and collaborate working toward a common goal. With that in mind, let's begin our journey with a simple principle: Every object instance should be created by Koin. My only responsibility as a developer is to describe how each object should be instantiated, while Koin takes care of the creation process.SingletonSingleton Café generated by ChatGPT Koin makes it easy to define singletons, whether you're using the @Single annotation or the single { ... } DSL. By declaring a singleton, you're telling Koin to create and manage a single instance of that object for the lifetime of the application. In the example below, we define an HttpClient as a singleton: @Module class NetworkModule { @Single fun provideHttpClient(): HttpClient { return HttpClientBuilder.build( baseUrl = BuildKonfig.HOST, ) } ... } HttpClient is a class provided by Ktor, and it should typically be instantiated only once. By declaring it as a singleton, Koin ensures that the same HttpClient instance is shared throughout the application. The Singleton pattern is commonly used for objects tha

## When Feature Flags Weren't Enough

DevFeed: [When Feature Flags Weren't Enough](<https://devfeed.tech/articles/when-feature-flags-weren-t-enough-23984.md>)

Original publisher: [Read original article](<https://medium.com/mcdonalds-technical-blog/when-feature-flags-werent-enough-91a441e5cabd?source=rss----3bac42476d27---4>)

Author: Global Technology

Published: 2026-06-09T13:33:43Z

Content type: article

Language: en

Sources: [McDonald's Technical Blog - Medium](<https://devfeed.tech/sources/mcdonald-s-technical-blog-medium.md>)

Topics: [configuration](<https://devfeed.tech/topics/configuration.md>), [feature flags](<https://devfeed.tech/topics/feature-flags.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [version-control](<https://devfeed.tech/topics/version-control.md>), [pull-requests](<https://devfeed.tech/topics/pull-requests.md>), [ci](<https://devfeed.tech/topics/ci.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [ci](<https://devfeed.tech/tags/ci.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [configuration-management](<https://devfeed.tech/tags/configuration-management.md>), [devops](<https://devfeed.tech/tags/devops.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [software](<https://devfeed.tech/tags/software.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [version-control](<https://devfeed.tech/tags/version-control.md>)

### AI overview

McDonald's engineers describe replacing a third-party feature-flag platform with a remote configuration system for structured, hierarchical restaurant settings. The system treats configuration like code through version control, pull requests, CI validation, peer review, and auditable live delivery to running backend services without redeployment.

### Source excerpt

We rebuilt remote configuration because tooling must match the problem and working like code with review, validation, and live delivery without redeploys. By: Mikhail Baranov, Software Engineer III, & Erick Lopez, Software Engineer III Quick Bytes: Feature flags worked for tracking changes, but they fell short when we needed richer configuration across thousands of restaurants We rebuilt remote configuration to work like code -- version-controlled, validated in CI, and delivered live to running services without redeploys Teams now manage configuration by exception, ship changes safely in real time, and operate with far more confidence and control Runtime configuration carries real weight in a restaurant technology environment. Thresholds get tuned. Features roll out region by region. One location needs a special rule; another needs a noisy signal dialed down. These aren't hypotheticals -- they're everyday decisions that shape how our backend fleet behaves across thousands of restaurants. For a long time, we managed these decisions through a third-party feature-flag platform. It gave us auditability and a clear record of who changed what. But over time, an uncomfortable truth emerged: the tool wasn't built for the shape of our problem. We didn't need toggles and targeting rules. We needed rich, structured configuration -- hierarchical defaults, per-restaurant overrides, clear environment promotion, and real-time delivery to distributed backend services. Forcing that model into a flags-first product created friction: awkward workarounds, unnecessary cost, and extra operational steps for changes that should have felt routine. We wanted configuration changes to feel as safe and controlled as code changes, while still reaching running services immediately. So, we set out to build exactly that. Treating configuration like a managed product Our solution treats configuration with the same rigor as production code. Structured configuration lives in version control. Changes move

## Sitar-agent: Building a reliable dynamic configuration sidecar at scale

DevFeed: [Sitar-agent: Building a reliable dynamic configuration sidecar at scale](<https://devfeed.tech/articles/sitar-agent-building-a-reliable-dynamic-configuration-sidecar-at-scale-1223.md>)

Original publisher: [Read original article](<https://medium.com/airbnb-engineering/sitar-agent-building-a-reliable-dynamic-configuration-sidecar-at-scale-b7e00c152068?source=rss----53c7c27702d5---4>)

Author: Bo Teng

Published: 2026-06-04T17:01:04Z

Content type: article

Language: en

Sources: [The Airbnb Tech Blog - Medium](<https://devfeed.tech/sources/the-airbnb-tech-blog-medium.md>)

Topics: [configuration](<https://devfeed.tech/topics/configuration.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [s3](<https://devfeed.tech/tags/s3.md>), [scale](<https://devfeed.tech/tags/scale.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [sync](<https://devfeed.tech/tags/sync.md>)

### AI overview

Airbnb describes Sitar-agent, a Kubernetes sidecar that reliably delivers dynamic configuration to service pods. It bootstraps from S3 snapshots, then synchronizes newer configuration from the Sitar Service.

### Source excerpt

How Airbnb built a Kubernetes sidecar to deliver dynamic configuration reliably at scale. By: Bo Teng, Cosmo Qiu, Siyuan Zhou, Ankur Soni, Xin Huang, Willis Harvey Introduction In our previous post, we explored Airbnb's dynamic configuration system, Sitar, with a focus on service architecture and configuration change safety. Now for the harder question: once a config change is committed, which happens several times each minute, how does it actually reach the thousands of Airbnb's service instances reliably, quickly, and without redeploying the services? This post describes sitar agent: a lightweight Kubernetes sidecar that runs alongside every subscribed service pod, continuously synchronizing the latest configurations from the service backend and making them available on the local filesystem for reads. In this post, we will first go through the configuration delivery life cycle, and then discuss some key design choices for the sitar-agent sidecar. Config delivery life cycle The diagram below illustrates the end-to-end journey of a configuration change, from the developer-facing layer to the production service fleet. Sitar config delivery lifecycle Step 1 -- Config creation/update Developers create or update configuration values through either Git flow or the web UI. These changes are committed to the Sitar Service, where they are stored with full versioning, change logs, and ACL enforcement. Step 2 -- Hourly snapshot upload The Snapshot Service periodically packages the full state of all config groups and uploads compressed snapshots to AWS S3. Step 3.1 -- Preload snapshot from S3 (on pod startup) When a production service pod starts, the sitar-agent sidecar runs first. It downloads the latest snapshot for each subscribed tenant's configs from S3 to the mounted disk (shared between sitar-agent and the main container). This allows the agent to bootstrap from a known-good state without fetching every config from the Sitar Service from scratch on every restart. Preloadin

## Migrating from a Monolithic Orchestrator to Apache Airflow

DevFeed: [Migrating from a Monolithic Orchestrator to Apache Airflow](<https://devfeed.tech/articles/migrating-from-a-monolithic-orchestrator-to-apache-airflow-30518.md>)

Original publisher: [Read original article](<https://medium.com/helpshift-engineering/migrating-from-a-monolithic-orchestrator-to-apache-airflow-30fde94bcdc0?source=rss----3229f31ca4f4---4>)

Author: Poorva Patil

Published: 2026-06-03T09:20:17Z

Content type: article

Language: en

Sources: [Helpshift](<https://devfeed.tech/sources/helpshift.md>)

Topics: [airflow](<https://devfeed.tech/topics/airflow.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Python](<https://devfeed.tech/topics/python.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>)

Tags: [apache-airflow](<https://devfeed.tech/tags/apache-airflow.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [aws](<https://devfeed.tech/tags/aws.md>), [clojure](<https://devfeed.tech/tags/clojure.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [etl](<https://devfeed.tech/tags/etl.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [python](<https://devfeed.tech/tags/python.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The article describes a migration from a monolithic Clojure-based scheduler to Apache Airflow. The legacy system coupled event pipelines, dependencies, and an EMR step, making workflows difficult to understand, maintain, monitor, and debug. The authors report that Airflow's Python-based DAGs made dependencies, retries, and scheduling more readable and helped improve onboarding and maintainability.

### Source excerpt

Photo by Corinne Kutz on UnsplashBefore we knew better Our orchestration system started as a simple internal solution to manage event pipelines and trigger downstream jobs. Over time, as more workflows and dependencies were added, it gradually evolved into a tightly coupled monolithic scheduler that became increasingly difficult to understand and maintain. Understanding how a workflow executed often meant looking through multiple files, configurations and database tables. For newer team members, onboarding into the system took time because much of the workflow context was distributed across different parts of the codebase. Even relatively small changes required careful coordination to ensure existing pipelines continued to work as expected. Similarly, debugging typically involved manually tracing logs and rerunning jobs to better understand execution behavior. Limitations of our legacy design We had a monolithic architecture written in Clojure that bundled all our event pipelines together, added dependencies between them and triggered a Lambda function. Legacy Workflow This Lambda function added a single monolithic step to the EMR cluster. If there was an issue in any one of the pipelines, the entire flow would fail due to the single step on the cluster. We did not have step-wise monitoring in the old design, so during on-call situations it became very difficult to identify which part of the pipeline was causing the issue. Photo by Tim Gouw on Unsplash There was no single place to answer basic questions like: What runs first? What happens if this step fails? How do I re-run just one part safely? The scheduler worked, but it was hard to understand, hard to maintain and even harder to explain. That's when we realized we needed a better way. What we actually needed Our aim was less about fancy scheduling features and more about making our daily work easier and more reliable. Simpler onboarding, less mental overhead Our existing step scheduler was built in Clojure and c

## How Endava builds an agentic organization with Codex

DevFeed: [How Endava builds an agentic organization with Codex](<https://devfeed.tech/articles/how-endava-builds-an-agentic-organization-with-codex-6391.md>)

Original publisher: [Read original article](<https://openai.com/index/endava>)

Published: 2026-05-28T12:00:00Z

Content type: article

Language: en

Sources: [OpenAI News](<https://devfeed.tech/sources/openai-news.md>)

Topics: [codex](<https://devfeed.tech/topics/codex.md>), [coding](<https://devfeed.tech/topics/coding.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [engineering-culture](<https://devfeed.tech/topics/engineering-culture.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [codex](<https://devfeed.tech/tags/codex.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [learning](<https://devfeed.tech/tags/learning.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-delivery](<https://devfeed.tech/tags/software-delivery.md>)

### AI overview

Endava uses Codex to build an agentic organization in which senior expertise is encoded into agents that support teams across requirements analysis, design, development, operations, and delivery. The approach reduces requirements analysis from weeks to hours and helps junior developers produce more mature work while learning software architecture and development practices.

### Source excerpt

Learn how Endava uses Codex to build an agentic organization, accelerating software delivery and reducing requirements analysis from weeks to hours.

## If Hope is Your Strategy, You're Doing On-Call Wrong

DevFeed: [If Hope is Your Strategy, You're Doing On-Call Wrong](<https://devfeed.tech/articles/if-hope-is-your-strategy-you-re-doing-on-call-wrong-17870.md>)

Original publisher: [Read original article](<https://www.codemotion.com/magazine/backend/software-architecture/if-hope-is-your-strategy-youre-doing-on-call-wrong/>)

Author: Natalia de Pablo Garcia

Published: 2026-05-19T10:05:05Z

Content type: article

Language: en

Sources: [Backend Job: skill, salary and insights - Codemotion Magazine](<https://devfeed.tech/sources/backend-job-skill-salary-and-insights-codemotion-magazine.md>)

Topics: [DevOps](<https://devfeed.tech/topics/devops.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [site-reliability-engineering](<https://devfeed.tech/topics/site-reliability-engineering.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [careers](<https://devfeed.tech/tags/careers.md>), [devops](<https://devfeed.tech/tags/devops.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [on-call](<https://devfeed.tech/tags/on-call.md>), [operational](<https://devfeed.tech/tags/operational.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The article promotes a Codemotion Madrid 2026 talk about improving on-call operations through proactive monitoring, well-defined runbooks, and intelligent alerting. It argues that these practices help engineering teams manage incidents and operate critical systems at scale, particularly in finance.

### Source excerpt

Codemotion Madrid 2026 is fine-tuning every detail to welcome a new edition packed with knowledge, business opportunities, and networking. Among the wide range of topics ahead, DevOps will play a key role at a time when, although everything moves at breakneck speed, security and stability remain non-negotiable. In the talk "If Hope is Your Strategy,... Read more The post If Hope is Your Strategy, You're Doing On-Call Wrong appeared first on Codemotion Magazine.

## From Single Instance to Split-Brain: A Database Scaling Journey

DevFeed: [From Single Instance to Split-Brain: A Database Scaling Journey](<https://devfeed.tech/articles/from-single-instance-to-split-brain-a-database-scaling-journey-22540.md>)

Original publisher: [Read original article](<https://medium.com/walmartglobaltech/from-single-instance-to-split-brain-a-database-scaling-journey-8b6a27a65023?source=rss----905ea2b3d4d1---4>)

Author: Alok Mishra

Published: 2026-03-31T18:40:52Z

Content type: tutorial

Language: en

Sources: [Walmart Global Tech](<https://devfeed.tech/sources/walmart-global-tech.md>)

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Self-hosted](<https://devfeed.tech/topics/self-hosted.md>), [backups](<https://devfeed.tech/topics/backups.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [Amazon EC2](<https://devfeed.tech/topics/amazon-ec2.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [backups](<https://devfeed.tech/tags/backups.md>), [bare-metal](<https://devfeed.tech/tags/bare-metal.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-services](<https://devfeed.tech/tags/cloud-services.md>), [cloud-sql](<https://devfeed.tech/tags/cloud-sql.md>), [cockroachdb](<https://devfeed.tech/tags/cockroachdb.md>), [database](<https://devfeed.tech/tags/database.md>), [ec2](<https://devfeed.tech/tags/ec2.md>), [failover](<https://devfeed.tech/tags/failover.md>), [google](<https://devfeed.tech/tags/google.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [google-cloud-sql](<https://devfeed.tech/tags/google-cloud-sql.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [production](<https://devfeed.tech/tags/production.md>), [read-replica](<https://devfeed.tech/tags/read-replica.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

This article explains how database scaling commonly uses a single-leader architecture with asynchronous read replicas. It discusses replication lag, stale reads, split-brain risks, read/write traffic separation, and the operational responsibilities of self-managed versus fully managed database services.

### Source excerpt

I used to think adding a 'Read Replica' was a magic button for scaling applications. I was wrong. While splitting read and write traffic is a standard system design pattern, implementing it introduces a world of pain - from stale reads to the dreaded Split-Brain problem. Here is how database replication actually works, and how to survive the transition. When people talk about "scaling databases" or "adding read replicas", they are almost always thinking about one specific architecture: Single-leader (Primary-Replica) architecture with asynchronous replication This is the architecture used by: MySQL + replicas PostgreSQL + streaming replication Google Cloud SQL PlanetScale, Neon, Supabase, etc. There is exactly one node that accepts writes -> called the Primary (or Leader/Master). All other nodes are Read Replicas -> they apply changes from the primary as fast as they can, but always with some delay (replication lag). This is the default and dominant model in 99% of applications today. Alternative architectures exist (multi-primary, leaderless, CRDTs, etc.), but they are rare and come with their own very different trade-offs. The second axis that actually matters in practice is: Who manages the replicas and failover for you?1. Self-hosted / Self-managed You run MySQL or PostgreSQL yourself (on EC2, Kubernetes, bare metal, etc.). You are 100% responsible for: Setting up replication Promoting a new primary when the old one dies Routing traffic correctly Handling replication lag Monitoring, backups, point-in-time recovery, etc. 2. Fully-managed cloud services RDS, Aurora, PlanetScale, Neon, Supabase, CockroachDB, Spanner, YugabyteDB, etc. The provider gives you a single connection string (or two: one for writes, one for reads) and magically keeps it pointing to healthy nodes, handles failover in seconds, and often hides (or eliminates) replication lag headaches. This second axis is the one that determines how much pain you will actually feel in production. Now, suppose yo

## Modularizing SOLR Query Creation for Multi-Market Scale

DevFeed: [Modularizing SOLR Query Creation for Multi-Market Scale](<https://devfeed.tech/articles/modularizing-solr-query-creation-for-multi-market-scale-22544.md>)

Original publisher: [Read original article](<https://medium.com/walmartglobaltech/modularizing-solr-query-creation-for-multi-market-scale-a1f34e28b631?source=rss----905ea2b3d4d1---4>)

Author: Naman Parikh

Published: 2026-03-03T12:18:55Z

Content type: tutorial

Language: en

Sources: [Walmart Global Tech](<https://devfeed.tech/sources/walmart-global-tech.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [implementation](<https://devfeed.tech/topics/implementation.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [debug](<https://devfeed.tech/topics/debug.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [code](<https://devfeed.tech/tags/code.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [developer](<https://devfeed.tech/tags/developer.md>), [errors](<https://devfeed.tech/tags/errors.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [information-retrieval](<https://devfeed.tech/tags/information-retrieval.md>), [modular-monolith](<https://devfeed.tech/tags/modular-monolith.md>), [monolithic-architecture](<https://devfeed.tech/tags/monolithic-architecture.md>), [regression](<https://devfeed.tech/tags/regression.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [technical](<https://devfeed.tech/tags/technical.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

This article describes modularizing a 12,000-line SOLR query creation implementation used across multiple markets. It explains how separating query concerns, adding market-specific configuration, and using stronger typing aimed to reduce coupling, regression risk, and runtime errors.

### Source excerpt

Introduction When the SOLR query logic expanded into a 12,000-line monolithic implementation, each modification introduced significant risk, making every change feel akin to defusing a critical system. Adding a market-specific override required yet another if block, compounding complexity and slowing time-to-market. In this article, we will deep dive how we broke that SOLR query creation logic, enabling clean configuration per market, stronger typing, reducing technical debts and dramatically reduced runtime errors. Image generated with DALL-E via ChatGPTThe Problem: When SOLR Queries Creation Logic Become Technical Debt The SOLR query logic class was handling filtering logic, boosting logic, boost functions, pagination etc. All the parameters related to SOLR query was getting generated using single class. Overthe time, this core class handled various logics related to different type of queries: Primary search queries Item insertions via business tools Item insertions via semantic sources Thousands of lines tangled edge-case handling, scoring tweaks, and boosting logic. This unscalable approach: Blocked rapid iteration for new markets Tight Coupling: All query-handling logic lived in one massive class, making it difficult to cleanly separate concerns. Market-specific changes could unintentionally affect unrelated logic, requiring exhaustive regression testing. High Risk of Unintended Consequences: Changing business requirements (such as supporting different filtering or boosting strategies for a new market) entailed changing existing code that already served other markets. Developers had to be extremely cautious, as a bug or oversight could break unrelated functionality. No Configuration Flexibility: There was no clear system for externalizing market-specific configuration. Instead, all logic changes happened directly in code, preventing business users or product managers from making simple market changes without developer intervention. Increased Runtime exceptions

## From a single point of failure to a cell-based architecture: How we scaled Mercado Envíos' stock...

DevFeed: [From a single point of failure to a cell-based architecture: How we scaled Mercado Envíos' stock...](<https://devfeed.tech/articles/from-a-single-point-of-failure-to-a-cell-based-architecture-how-we-scaled-mercado-envios-stock-22551.md>)

Original publisher: [Read original article](<https://medium.com/mercadolibre-tech/from-a-single-point-of-failure-to-a-cell-based-architecture-how-we-scaled-mercado-env%C3%ADos-stock-528f581fb71b?source=rss----5011f85401f0---4>)

Author: Rafael Silvestri

Published: 2025-12-29T21:09:09Z

Content type: article

Language: en

Sources: [Mercado Libre Tech](<https://devfeed.tech/sources/mercado-libre-tech.md>)

Topics: [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [migration](<https://devfeed.tech/topics/migration.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [cell-based-architecture](<https://devfeed.tech/tags/cell-based-architecture.md>), [database](<https://devfeed.tech/tags/database.md>), [database-scalability](<https://devfeed.tech/tags/database-scalability.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [fury](<https://devfeed.tech/tags/fury.md>), [internaldeveloperplatform](<https://devfeed.tech/tags/internaldeveloperplatform.md>), [migration](<https://devfeed.tech/tags/migration.md>), [outages](<https://devfeed.tech/tags/outages.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

This article explains how Mercado Libre migrated Mercado Envíos' consolidated MySQL-based stock system into independent cells using a cell-based architecture and Fury. The migration was intended to isolate failures, reduce systemic risk, and provide more predictable scalability after the regional database reached its vertical-scaling and operational limits.

### Source excerpt

From a single point of failure to a cell-based architecture: How we scaled Mercado Envíos' stock system How we migrated Mercado Libre's second-largest MySQL instance into independent cells using Fury, reducing risk and achieving predictable scalability in Fulfillment. Abstract What happens when the database supporting a continent's logistics reaches its limits? We reached that point when a critical regional database, used for inventory operations across Latin America (LATAM), could no longer scale vertically. This article describes how we transitioned from that consolidated model to a cell-based architecture -- isolating failures, reducing systemic risk, and improving operational predictability -- while keeping logistics running throughout the migration. When a core system reaches its breaking point Software architecture uses patterns to prevent local failures from causing global outages. One of them is the cell-based architecture, which is conceptually similar to the naval bulkhead mechanism. Ships use watertight compartments, or bulkheads, to divide the hull into separate sections. If one compartment floods, the others remain sealed and the ship keeps moving. In distributed systems, we apply the same idea: each cell operates autonomously, with its own compute, database, and traffic. If one cell fails, the rest continue serving requests. This isolation reduces the blast radius and increases resilience. This pattern became essential at Mercado Libre when the stock system powering Mercado Envíos reached its operational limit. Every inbound, outbound, reservation, and logistics movement depended on a single database that could no longer scale. By early 2024, the question was clear: What do you do when vertical scaling is no longer an option? The problem: One database serving all of LATAM Our initial architecture was simple: multiple stock services connected to a single MySQL cluster. This cluster managed: Stock availability per Fulfillment Center Reservations for Fulfil

## Closing SSE Connections: A Browser Compatibility Deep Dive

DevFeed: [Closing SSE Connections: A Browser Compatibility Deep Dive](<https://devfeed.tech/articles/closing-sse-connections-a-browser-compatibility-deep-dive-37520.md>)

Original publisher: [Read original article](<https://blog.apartment304.com/sse-close-connection/>)

Author: James Heller

Published: 2025-11-20T19:00:00Z

Content type: tutorial

Language: en

Sources: [Apartment 304](<https://devfeed.tech/sources/apartment-304.md>)

Topics: [Server-sent events (SSE)](<https://devfeed.tech/topics/server-sent-events-sse.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [htmx](<https://devfeed.tech/topics/htmx.md>), [HTTP](<https://devfeed.tech/topics/http.md>), [Firefox](<https://devfeed.tech/topics/firefox.md>), [Chrome](<https://devfeed.tech/topics/chrome.md>)

Tags: [ajax](<https://devfeed.tech/tags/ajax.md>), [apartment-304](<https://devfeed.tech/tags/apartment-304.md>), [browser](<https://devfeed.tech/tags/browser.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [custom-software-solutions](<https://devfeed.tech/tags/custom-software-solutions.md>), [devops](<https://devfeed.tech/tags/devops.md>), [devops-engineer](<https://devfeed.tech/tags/devops-engineer.md>), [htmx](<https://devfeed.tech/tags/htmx.md>), [http](<https://devfeed.tech/tags/http.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [issue](<https://devfeed.tech/tags/issue.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [multiplayer](<https://devfeed.tech/tags/multiplayer.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineer](<https://devfeed.tech/tags/software-engineer.md>), [sse](<https://devfeed.tech/tags/sse.md>)

### AI overview

This tutorial explains how Server-Sent Events connections can remain open inconsistently across browsers when users navigate away. Using the multiplayer mystery game Whodunit with HTMX as an example, it describes SSE connection tracking and a client-side JavaScript approach for robust cleanup.

### Source excerpt

When browsers leave connections dangling, your app can get stuck waiting for users who are already gone. Let's solve the mystery of closing SSE connections.

## \*People\* detangle a ball of mud

DevFeed: [\*People\* detangle a ball of mud](<https://devfeed.tech/articles/people-detangle-a-ball-of-mud-37632.md>)

Original publisher: [Read original article](<https://swizec.com/blog/people-detangle-a-ball-of-mud>)

Author: hi@swizec.com (Swizec Teller)

Published: 2025-11-15T00:00:00Z

Content type: opinion

Language: en

Sources: [Swizec Teller](<https://devfeed.tech/sources/swizec-teller.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Development](<https://devfeed.tech/topics/development.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [async](<https://devfeed.tech/tags/async.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [processes](<https://devfeed.tech/tags/processes.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [teams](<https://devfeed.tech/tags/teams.md>)

### AI overview

This opinion argues that teams and processes, rather than a lone architect, are the best way to gradually untangle a deteriorating "ball of mud" codebase. Giving teams ownership, allowing space for refactoring, formalizing recurring patterns, and discussing interfaces before coding can encourage decoupled subsystems.

### Source excerpt

Ball of mud is the world's most popular software architecture. The one we all use at work. But it sucks to work with. So what do you do?

[Next page](<https://devfeed.tech/tags/software-architecture.md?cursor=WyIyMDI1LTExLTE1VDAwOjAwOjAwKzAwOjAwIiwgImE0NGNlMzBiLWJlYmUtNDEyYS1hZTQ3LTQ4OWQ2YWJiYjY5NyJd>)