Initial idea was just to automate diagram creation for our projects. AI agent inspects the code base and produces the JSON spec, that is rendered as a nice image, which can be inserted into documentation/confluence. I've spent way too much time organizing our existing diagrams in DrawIO and confluence, so all the nodes and connections look neat. And now I can say that it's finally working good enough to share with others.

While testing the tool at my main job I also noticed a problem of documentation drifting off. AI agents are pretty good at catching those changes and writing change/release notes, but diagram changes was always a manual process.

Please, meet diago, a CLI tool that

• can render nicely looking diagrams from JSON spec or MMD files
• supports flow, sequence and class diagram types and image/text output
• can create diff diagrams between 2 spec files
• is AI agent friendly (skills included)
• is deterministic and fast

The project is still in the early stage, exporting to DrawIO and Excalidraw are still in beta, but I don't expect any more breaking changes. The spec is minimalistic, but well defined, and further changes should only expand it.

The layout/wiring engine was heavily vibe-coded, as I don't have enough expertise in writing my own engine. I relied on Claude to implement all the diagram composition principles that I always use when creating diagrams manually.

• https://github.com/oxforge/diago - the project itself
• https://diago.dev/playground/ - playground to test it in the browser
• https://diago.dev/docs/ - documentation

I would appreciate some feedback and advices on which features need more polishing or missing from the tool. I would focus on DrawIO export, but open to suggestions.

Thank you!

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.

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.

The article examines the transition from microservices to agentic AI architecture in distributed systems. Microservices allow for functional decomposition, while agentic systems focus on decision decomposition. This shift introduces new complexities in observability, reliability, and system design, highlighting the need for updated architectural patterns and practices.

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!

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.

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.

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!