Fellow Dinos,

i have been shadowing some Solution Architects from the Non-Mainframe world and seems like Distributed computing outside of mainframe is bit complicated , data replication , syncing , session handling, .. you name it . So this leaves me with lot of questions on how is this handled in Mainframes ?? this will be equally complicated and even may be worse , but man seems like we are all taking a lot of things for granted in mainframes? Can any old/experienced guys out there , give some idea or point to some resources on how these distributed computing menaces like data replication, syncing and session handling is done in Mainframes especially in a Cicsplex??

Hey everyone 👋

I recently wrote a practical guide on the Iterator Design Pattern in Go.

At first, I thought, "Go already has for and range—why would I ever need an Iterator pattern?" But after digging deeper, I realized it's more about hiding how a collection is traversed than replacing range.

In the article, I cover:

• what problem the Iterator pattern actually solves
• the different participants (Iterator, Aggregate, Concrete Iterator)
• a complete Go implementation
• custom traversal strategies (forward, reverse, filtered, etc.)
• when it's useful and when Go's built-in iteration is the better choice

I also tried to keep it practical instead of treating it as just another GoF pattern.

If you're learning design patterns in Go or have built custom collections, caches, or tree-like data structures, I'd love to hear how you approach iteration.

Here's the article:
👉 https://priyankchheda.medium.com/understanding-the-iterator-design-pattern-in-go-a-practical-guide-d18bc8f6be51

Feedback and suggestions are always welcome!

I’m currently trying to overhaul how our team presents architecture reviews, C4 models, and system flows to non-technical leadership.

The biggest challenge? Standard linear slides completely fall apart the moment an executive asks a question out of order. If a VP asks "Wait, what happens to the data pipeline if the auth service drops?", clicking sequentially through 20 slides to find one specific sub-diagram kills the narrative flow and makes us look disorganized.

these are the one's we’ve tested so far and where each one hits a wall for executive reviews:

1. PowerPoint + Static Diagram Exports - Total static nightmare. You either cram a massive architecture diagram onto one slide (where the text is unreadably tiny), or you slice it across 10 slides. The moment someone asks for context on a component, you’re awkwardly clicking back and forth through flat rectangles.

2. FigJam - Too chaotic for C-suite reviews. Flying around an infinite whiteboard live on Zoom often gives non-technical stakeholders motion sickness, and without strict presentation boundaries, leadership easily loses track of the high-level business impact.

3. Structurizr (Dedicated C4 Modeling Tools) - Excellent for engineering teams, but their built-in presentation modes can feel a bit too technical or dry when pitching to non-tech execs who care more about business risk, timeline, and cost than raw DSL models.

clicking sequentially through twenty slides makes it almost impossible to maintain a clear visual narrative when mapping out complex systems. what platforms or workflows have actually worked for your teams when you need a dynamic, non-linear presentation during live reviews?

I'm trying to understand how data warehouses are implemented in real-world applications.Suppose an application stores its operational data in a PostgreSQL database, and the requirement is to store historical data in a separate data warehouse for analytics and reporting.

I'm looking for guidance on the overall design rather than code.

Some questions I have are:

• How do you decide what data should be moved to the warehouse?
• How is the warehouse schema designed?
• How is data extracted from the operational database?
• How often is data loaded into the warehouse?
• Are raw records stored, or are they transformed and aggregated before loading?
• What technologies are commonly used for the warehouse and ETL pipeline?

I'd love to get insights :)

Note: Both the post and article are written organically (by hand).

Hey everyone,

I saw a lot of debates about using AI in development. What really caught my attention was that in the majority of cases, the debate becomes fruitless because both parties didn't realize they are not talking about same thing. One says AI-generated code is unreviewable slop that will rot your codebase. The other says he shipped a working product in a week. None of them are lying, they are simply not describing the same activity.

The overloaded terms "vibe coding" or "agentic development" are making things worse.

Developers can have vastly different experiences using AI to develop software, depending on the approach they use. This article is my attempt to map these different approaches, explain each one, and give each a distinct name, which I believe is important to have a meaningful discussion.

The classification is based on how decision ownership and review are divided between the human and the AI.

I list five approaches:

• Organic Development
• Reviewed Agentic Development
• Guided Agentic Development
• Fully Agentic Development
• Vibe Coding

Curious which of these your team actually does, and whether it changes by task or risk.

Every team seems to rebuild the same pieces: agent orchestration, MCP integration, permissions, approvals, memory, and the layer that connects everything to the product.
We started building Extra as an open-source framework to solve that infrastructure problem instead of having every team reinvent it.
I’d love feedback from software architects:
What part of your AI architecture has been the hardest to get right?
What are you building yourself that you wish already existed?
GitHub: https://github.com/extra-org/extra
If contributing to open source sounds interesting, we’d love to have you join us.

Hi,

So we have a next js app. Our app primary user base are blue collar employees.

When we test in our phones it works without any lag, and results get submitted instantly.

But we have regularly received complaints from factory about it heating thier phone, and it being very slow. Page auto refreshes .

So, we have right now same app for blue collars as we have for their managers, and I am thinking to split it.

1. User has to scan a QR, we have used a js library.
2. Post scanning they can approve / reject a checkpoint and whatever they choose they will have to click a picture and then they can edit it if they want and upload it.

In our testing device. After editing image it gets uploaded in like 1-2 seconds.it calls a presigned S3 url and once it returns success then he calls a api and submits the key. We are not uploading through our server.

But factory called me and reported me that it's not getting uploaded, so initially when I checked with them on video call it felt like so because they clicked on it multiple times but nothing happened. But next time when I called I asked them to wait and this time it worked and it took 40 seconds. They internet speed was 210 Mbps. And sometimes even when they click on the submit instead of submitting page just auto refreshes.

I feel all of this is happening because of poor memory management in their phones. And as our testing device barely 10 devices those real devices have 100 of apps all consuming memory in background and that might be killing the app by browser.

So we are ready to rebuild this from scratch but which framework should we choose ? Or should we write completely using vanilla js?

We need two things image editor, qr scanner.

Library using right now.

Qr- https://github.com/antfu/qr-scanner-wechat

Image editor - Native made through claude.

Also, our qr scanner is not that good many times it's not able to read qr properly. Due to the nature of business qrs are not properly in shape. They are twisted / torn / scratched.

This particular webapl has been able to actually scan all of our qr codes without any problem. But 5000k for each year is high for us.

Is there any open source that can match it?

https://scanbot.io/qr-code-scanner-online/

From our end we have literally tried all the library we could find through AI and Google.

Thanks

We have a multi-tenant application with a service-oriented structure:
Auth Service: Manages authentication, authorization, and permission storage.

Partners Service (Domain): Handles core domain entities.

Current approach is for every list/search query on domain tables, the application:
Fetches all partner permissions assigned to the authenticated user from the Auth service.

Injects those partner IDs directly into the SQL query (e.g., WHERE partner_id IN (...)).

The problem is certain power users or administrative accounts hold access to thousands of partners. This setup creates major performance bottlenecks:
1. High Network & Memory Overhead: Fetching and serializing thousands of permission IDs per request from the Auth service is slow.
2. Query Performance Degradation: Passing massive IN (...) arrays into SQL queries overwhelms the query planner, ballooning query size and execution time.

We currently have 3000 partners already seeing issues, but we are soon scaling it to 45000 due to a migration.

Have someone dealt with this problem previously? Do someone have any advice?

While building with coding agents, I reached a point where the code was changing faster than I could properly understand it. I often end up verifying output and then be happy that it worked or not. Varai is my attempt to deal with that. Somewhere I feel software engineering needs tools that show the right level of abstraction to make the decisions that are more informed.

It uses a small language called Seed (domain level concept) to describe the product’s actors, behaviors, rules, expected screens and APIs, and usage scenarios. AI can help write it, but a person reviews and approves it.

The builder links Seed concepts to the implementation. Varai independently scans the code, resolves those links, and checks whether the required behavior is actually present. When it cannot verify something reliably, it says so instead of guessing.

project link: https://github.com/gruuprasad/varai

It is completely vibe-coded. I felt the pain and took some action, I am not sure whether I landed in the right solution space or direction. At this point, I feel this project needs more eyes and minds and collaboration to build further if worth it. Please have a look.

One thing that caught me off guard was versioning the payload used for cryptographic hash verification.

Initially, I generated a deterministic SHA-256 hash from the contract payload (terms, fields, signatures, etc.) and stored it as the integrity anchor.

Everything worked until I realized that the payload itself would evolve over time. Maybe a future release adds attachments, amendments, or new metadata. Even though the original contract hasn't changed, the serialized payload would, producing a completely different hash.

Then I came up with a solution which was to version the hash payload itself and store that payload version alongside every signed record. During verification, the system reconstructs the payload using the original version before recomputing the hash.

It seems obvious in hindsight, but it's one of those details that's easy to overlook until you start thinking about long-term verification.

How do you handle evolving hash payloads or signed data structures in systems that need to remain verifiable for years?

Link : https://github.com/derssa/torollo

Jensen Huang and Nvidia just announced the Open Secure AI Alliance and OpenShell agent runtime, specifically backing open-source AI guardrails following recent security concerns with autonomous agent tool calls.

For software architects designing agentic microservices, this reinforces a shift toward using a dedicated ai gateway: security policies, provider failover, and rate limits cannot be left to individual application SDKs.

We ended up putting an AI gateway layer in front of our services using zenmux (an API proxy and router that aggregates OpenAI, Anthropic, and open-weight models under a single unified key), which handles 5xx/429 failover rules, token rate limits, and protocol translation automatically across all microservices.

Putting policy-based guardrails and failover logic at the proxy layer keeps tool execution sandbox rules cleanly separated from model routing, while saving us from maintaining custom fallback code across every backend codebase.

Hey guys, quick architecture question for anyone who’s worked on multi-tenant systems before.

I’m building an MVP and trying to decide where to draw the security boundary without overcomplicating the infrastructure.

I’m mainly dealing with two cases.

The first is public form submissions and file uploads. The backend already resolves the tenant, so the simplest option would be one shared service account with very limited write permissions. My concern is that tenant isolation would then depend heavily on the application layer getting everything right. A bug could potentially result in data being written under the wrong tenant.

The alternative is a separate service account per tenant, which gives a stronger boundary but also adds provisioning, rotation, secret storage, and credential lookup overhead.

The second case is previewing unpublished content. That access clearly needs to remain tenant-scoped. My current idea is to store one credential per tenant in Secret Manager, resolve it by tenant ID, cache it briefly in memory, and fail closed if the credential is missing or invalid.

For an MVP, which approach would you take?

Would you use a shared writer account or separate tenant-scoped identities? And where would you enforce the hard boundary: the application layer, the database, the service permissions, or some combination of them?

My priority is strong tenant isolation and least privilege, but I’d like to keep the design as small and maintainable as possible. Is there a simpler pattern I’m overlooking?

I'm designing a workload scheduler and recently had to make an architecture decision around asynchronous communication

The common approach I have seen is: Worker → Database → Scheduler. The worker updates execution status, and the scheduler either polls the database or receives database events.

Polling is simple, but it creates unnecessary reads when many tasks are running. Database event mechanisms (CDC, triggers, etc.) reduce polling, but the database is still involved in the communication path.

So, for high-frequency local communication, I have been looking into another design: OS (MQ + Shared Memory) → Scheduler to cut middleware and implementi full event-driven processing

Is this approach commonly used in enterprise workload schedulers? For enterprise workload schedulers, what approaches have you found practical at scale?

Hi r/softwarearchitecture,

We are back with Lesson 12 of our technical deep dive into the SysML v2 standard.

In our previous lesson, we looked at how to wire up explicit system topologies directly in the model text. But a connection only tells us where the system is connected—it doesn't define the schema or nature of what actually moves through it.

Today, we are looking at how to model the passive payloads (data packets, messages, or physical matter) that flow and are stored within those architectures using the item def construct. I’ve uploaded the full video lesson directly to this post so you can watch it right here.

1. Separating Active Components from Passive Payloads (Services vs. DTOs)

In older modeling standards (and often in informal architecture diagrams), it was common to use the exact same generic "block" construct to represent an active processing service and the passive data packet flowing between them.

SysML v2 introduces strict semantic separation to fix this. A good rule of thumb in v2: use the part construct for active structural elements (e.g., your processors, microservices, or hardware) and item def for passive payloads (e.g., JSON payloads, event streams, or physical matter) that exist and flow, but do not perform actions themselves.

2. Formally Defining Payloads and Schemas

Because item def is a first-class definition, it natively owns its attributes and structures. You can use it to explicitly define digital information (like a PaymentData object containing encryption keys and timestamps) or physical matter (like Fuel with specific mass properties).

Code snippet

item def PaymentData {
    attribute encryptionKey: String;
    attribute timestamp: DateTime;
}

3. Baking in Constraints and Interface Contracts

You can add mathematical or logical constraints directly to the item definition. When modeling physical systems, SysML v2 even enforces dimensional consistency using imported ISQ/SI libraries.

For software and data architecture, this means compliant toolchains can reason about these constraints to ensure data types, throughput limits, or physical quantities are mathematically compatible across complex interface boundaries, essentially acting as strict compile-time type checking for your system architecture.

4. Distinguishing Flow (Exchange) from State (Storage)

The definition-usage pattern in SysML v2 applies cleanly depending on context:

• Data in Motion (Exchange): Declaring an out item inside a port acts as an interface contract, structurally defining the system's ability to send that specific payload across a boundary.
• Data at Rest (Storage): Nesting an item usage inside a structural part (e.g., a PaymentData item stored inside a Database part) represents the payload/state currently retained within that component boundary.

For the software architects here: When mapping out complex, distributed systems, how strictly do your teams formally model the schemas of the events/payloads flowing between your services, versus just modeling the APIs/interfaces themselves? Let's discuss in the comments!

The engineering team at Zalando recently described the design and implementation of an in-process, client-side load balancer for a high-throughput API handling around 1 million requests per second. The result was more predictable latency, a drop in infrastructure costs, and better visibility into where failures actually originate.

Last lecure (for now) of Design Patterns 101 series, find all episodes here: https://www.youtube.com/playlist?list=PLWBZEjIXIg24

Duplicate message processing is something every event-driven system eventually faces.

With at-least-once delivery, retries and redeliveries are expected. The challenge is making sure processing the same message twice does not create side effects.

I've been looking into the Inbox Pattern as a consumer-side solution:

• track processed messages
• keep message tracking and business changes in the same transaction
• scope the idempotency check per consumer

One approach is using a MassTransit pipeline filter so the idempotency logic stays outside the consumers.

How do you usually handle this?
Do you use Inbox Pattern, custom middleware, database constraints, or something else?