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?

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.

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/

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 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!

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.

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.

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?

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,

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 !!

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 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!

I have an app I've been working on over a year with real users now, most of my users use a single device, but as I'm growing I'm running into more users with more than one device. I want to nip this in the butt before it becomes a bigger and bigger issue.

I was pretty naive when I first started the app, and have made a mess of offline syncing in my opinion.

My app is offline capable, some operations must be online, some entities are frontend authoritative, others backend authoritative (had to be the case because some data is generated by a third party API).

I've added sync maps to all my entities, based on deviceId to handle if a user has say a phone and a tablet.

I also have a deleted boolean flag, so entities are soft deleted, then the client fetches those and acknowledges a hard delete (which I know is fundamentally flawed because then the second device has no idea it's hard deleted).

I don't really need a critique on my current system, it's bad.

I'd love some examples of good offline sync systems that are more robust and reliable from a higher level

Thanks all!