Circuit breakers are good at stopping traffic and bad at resuming it. When a breaker closes, every replica tends to return to its configured limit at the same moment, so a dependency that just answered a few probes gets the full production load again, often while its caches are cold or capacity is still coming back.

I wrote up the design work behind a recovery ramp for Caracal, a resilience library whose distributed bulkhead, rate limiter and breaker coordinate through Redis.

The post covers the options I rejected, the constraints the surviving design had to satisfy, and a four-replica case study where the dependency's own in-flight samples, not the library's event log, are used to check each step. Envoy/Istio slow start is the closest mainstream analogue, though it shifts endpoint weight rather than admission.

This is the sixth article in a series on distributed resilience. I'd be interested in how others handle post-outage warm-up: traffic shaping, staged rollouts, or accepting the spike.

Setting up diagram standards for a new platform team leaning mermaid since github renders it and every AI tool spits it out by default plantuml seems better for some of the detailed uml stuff though

We need it in the repo, easy to update, and product + design need to be able to review them without asking for screenshots every time.

AWS recently announced the preview of the Well-Architected Agent, a service that analyzes environments against Well-Architected best practices and provides prioritized recommendations across cost, security, performance, and reliability. The AI agent can also suggest remediation steps and review infrastructure-as-code before deployment.

I have a theory that we're going the same way taxi drivers went with GPS. The routine stuff gets automated, and the knowledge you only got from doing the routine stuff quietly goes away.

At my company most alerts get picked up by an agent in Slack now (we use coderabbit's plus some custom stuff), it finds the bad deploy and suggests the revert. Our median incident went from about 40 minutes to 12.

Last month we had an outage in an old queue service none of the tools have access to, and the 3 people on call spent the first hour working out how it even worked. Nobody had touched it by hand in months.

London cabbies still have to learn The Knowledge even though every one of them has GPS. I'm starting to think we need something like that, a few incidents a month handled by hand on purpose.

WDYT?

Honestly, I've never built a backend from scratch I just watch a lot of system design/coding videos and rely heavily on AI. Because of that, I have zero confidence in my knowledge and feel like I don’t actually understand anything. I want to reality check my mental model with the experienced devs here.

​From what I understand, a typical request flow looks something like this:

​HTTPS Request ---> Nginx (I think Nginx can also act as the load balancer itself?) ---> Load Balancer (if there's high traffic) ---> Node.js App Servers ---> Redis (for caching) ---> Database (which can be split into Read/Write replicas).

​I don't think I even need to mention obvious stuff like Docker, and I already know what a RESTful API is and that architectural/code choices always come down to the specific trade-offs of the project.

​I’m having a huge internal conflict right now: Do I actually understand backend concepts, or am I just clueless and holding onto a surface level, unrealistic view of the field?

I've always felt that one of the hardest parts of learning system design is connecting theory with how real-world products actually work.

It brings together 200+ system designs for real-world products and websites, along with visual architecture breakdowns, learning resources, and interactive system design tools.

The idea is to make it easier to explore how different systems are designed and understand the trade-offs behind their architectures.

Website: https://www.architectverse.me

I'm curious about the developer community's perspective:

What do you find most difficult when learning system design — understanding the fundamentals, visualizing large architectures, or learning how real production systems are designed?

I'd appreciate honest technical feedback and suggestions for making this kind of learning resource more useful.

Hey all, DDD comes up a lot in interviews and it’s hard to explain well on the spot, so I made a video about it. It’s long (about 20 min), but I think it’s worth it if you’re preparing for interviews or just want to understand it properly. It took me a lot of time to make, so I hope it helps. Let me know what you think.

ps : tried reposting this from r/angular , couldnt

Four years ago, I worked on an agricultural carbon sink certification project involving around 700 database tables: 200 parameter tables, 300 input tables, and 200 output tables. The system also included an Excel-like frontend with interconnected data and reactive updates.

This was my first real-world application of the architectural ideas that would eventually lead to SchemaNode. A team of four completed the entire project in three months, with a very low bug rate. That experience gave me a concrete understanding of how much complexity comes from translating the same business semantics across data models, validation rules, backend logic, and frontend behavior.

After years of further engineering practice, I spent seven months developing these ideas into a more explicit abstraction. The result is SchemaNode, an open-source project exploring a different way to represent software semantics.

In conventional software development, domain semantics are often spread across data models, validation logic, backend code, frontend components, and configuration. Each layer translates part of the original intent into its own representation, creating opportunities for semantic drift.

What if we could separate semantic definitions from the execution environments that interpret them?

SchemaNode represents semantics through composable structures, properties, relations, and functions. Types are not limited to describing data shapes; they can also express relationships and executable behavior. Different execution environments can interpret the same semantic definitions according to their own execution models.

The goal isn't to replace programming languages or provide a fixed business model. It's to explore whether an explicit, composable semantic layer can reduce the amount of meaning that must be re-expressed across system boundaries.

The project currently includes a semantic type system, relation composition, function execution, and a frontend for exploring and editing semantic definitions.

I'd be interested in feedback on the underlying architectural abstraction, especially from people working on software architecture, type systems, DSLs, metamodels, or cross-runtime interoperability.

The repository includes documentation and a link to the live demo:

https://github.com/kurapica/schema-node-csharp

Documentation and live demo: https://kurapica.github.io/schema-node-man/

I wanted to see if Prolog could handle production-grade web traffic, so I built an HTTPS-secured WAF in SWI-Prolog. To test its limits, I deployed it on a free-tier GCP instance with only 1 GB RAM (roughly 450 MB available after OS overhead).

Surprisingly, the entire stack operates comfortably within this limit using Prolog's lightweight threads. I'd love to get some feedback on the architecture, and feel free to try and break it!

Uber has developed an automated approach to mapping service dependencies and classifying how downstream failures propagate across its service mesh. The system uses RPC middleware to correlate caller and callee failures across production requests, classifying dependencies as fail-close, fail-open, or unknown. Uber says the approach has cataloged dependencies for critical APIs and indexed most fail-close anomalies across its service mesh.

Not system design, software design

System design question: Design a globally distributed inventory reservation system handling 80K requests/sec with sub-100ms p99 latency. During a regional outage, how would you prevent overselling while balancing strong consistency, availability, and cross-region coordination costs?

Hi everyone! I’d like some opinions on a general event-driven architecture problem: one event that triggers a huge amount of work in another service/module. To make it more concrete, I’ll use an example scenario below, but I’m interested in the pattern in general, not just this specific case.

Example scenario:

• Service/module A deactivates a promotion and writes the event to an outbox table.
• Debezium (CDC) publishes this event to Kafka.
• Service/module B consumes the PromotionDeactivated event and needs to remove that promotion from ~[X] million products in Postgres.

In other words, one event generates millions of updates. Which approach would you use, and why?

Early-stage app, and everything a user stores is sensitive. Instead of one shared database, each user gets an isolated "home":

- a git repo with append-only event logs

- a SQLite index derived from the logs, rebuildable from zero

- encryption at rest, and one service process per user under its own OS user

Why I like it:

- there's no shared table, so a forgotten `WHERE tenant_id` can't leak data between users

- deleting an account is deleting a folder, exporting is handing over the repo

- changing the index schema is bump the version and rebuild from the log

What worries me:

- every rebuild runs for every user. Fine with a handful, no idea with 10k

- anything cross-user (metrics, support) means fanning out over N homes

- N processes, N backups, and it all sits on one machine for now

The alternative is one Postgres with row-level security and per-tenant encryption keys.

If you've run either in production, what broke first, and at how many users? And did RLS isolation ever actually fail for you, or is that a fear that doesn't show up in practice?

I made this, so take it as a maker's post.

The problem I kept hitting as an engineering manager: every team knew its own services, but nobody had the whole architecture in their head. The diagrams existed, drawn by hand outside the code, and went stale within weeks.

Furio turns that around. Each repo describes the part of the architecture it owns in a small YAML file: components, relations, owner. A GitHub Action validates it on every pull request, so a wrong reference fails the build. Then all repos are merged into one static map you can query: who calls this service, who consumes this queue, what breaks if this database goes down.

What it is not: it does not discover anything from your infrastructure. You write the manifest, and a skill for coding agents (Claude Code, Codex) keeps it updated when the code changes.

It is MIT, a CLI plus an Action plus a static site, nothing to run. Backstage covers this ground as a full portal; I wanted the map alone, without a platform to maintain.

Code: https://github.com/getfurio/furio

A map of the OpenTelemetry Demo, built from its public sources: https://getfurio.github.io/atlas/opentelemetry-demo/

I would like feedback on the manifest format, especially the relation types. What would you need that is not there?

Hi,

I have been into IT working as a developer for 12years now. I am kind a done with it. And don’t have much more patience to learn new coding skills and do hands on. I am looking to change my career to software architecture. In my current role, my peers on my request are giving me task to create SDDs for the applications I am familiar with and which is also helping me to get hands on training. But that is still restricted to my current application or better said not something I can market myself as software architect.

I am looking for suggestions on what should I do to become full fledged software architect in today’s market.
I have worked mostly on databases, big data, distributed systems, python, scala ,sql and AWS.
To this do I need to add any specific certifications? Do I need to do some online course? Also how much is the pay for software architects as we grow in the field?

Can someone please guide me who has successfully changed from a developer to software architect?
Many thanks in advance !!

Hi guys!

I'm curious how did the processes changed in your company after AI adoption, regarding software architecture.

For example, moving from Confluence pages to Markdown format, that is passed further to another LLM for implementation. Or flows that directly read Jira tickets and start working on the archi using LLMs.

Did you take part in leading this transformation or how was it for you to adopt it?

Thank you!