Skip to content
Tagged articles

system design

500 articles · Page 1 of 5
Architect's Guide
Architect's Guide
Nov 19, 2026 · Fundamentals

Why Reuse Can Be Evil in System Design: Autonomy Over Reusability

This article argues that pursuing reuse as a primary goal in system design often backfires, increasing coupling and maintenance burden; it advocates prioritizing module autonomy over forced reuse, using autonomy and consistency metrics to evaluate design decisions, and warns against over-generalization like excessive microservices or shared business platforms.

DRY principleautonomybusiness platform
0 likes · 9 min read
Why Reuse Can Be Evil in System Design: Autonomy Over Reusability
Java Architect Essentials
Java Architect Essentials
Nov 18, 2026 · Backend Development

Stop Manual Dragging: 34k-Star AI Tool Generates Editable Diagrams Inside draw.io

Next AI Draw.io embeds an AI chat panel directly into draw.io, producing editable nodes and connections that developers can manually refine or further modify via AI, supporting architecture diagrams, cloud topologies, and MCP integration for AI coding tools, with Docker and desktop deployment options.

AI diagram generationDocker deploymentMCP integration
0 likes · 7 min read
Stop Manual Dragging: 34k-Star AI Tool Generates Editable Diagrams Inside draw.io
macrozheng
macrozheng
Nov 17, 2026 · Backend Development

Elegant Payment System Design: From Business Decomposition to TCC Transactions

This article breaks down payment system design into business decomposition, sequence modeling, data structure design, and key technical patterns like TCC transactions, locking, and fund settlement, using e-commerce scenarios to illustrate each layer.

TCC transactionbackend developmente-commerce architecture
0 likes · 10 min read
Elegant Payment System Design: From Business Decomposition to TCC Transactions
Architect's Guide
Architect's Guide
Nov 16, 2026 · R&D Management

What Makes a Great Software Architect? 10 Core Skills Explained

This article breaks down the software architect role into three architecture levels, nine daily activities, and ten essential skills—including design patterns, decision-making frameworks, simplification principles, and hands-on coding—with references to GoF patterns, enterprise integration patterns, ThoughtWorks Tech Radar, and TOGAF.

Decision MakingDesign Patternsarchitecture skills
0 likes · 18 min read
What Makes a Great Software Architect? 10 Core Skills Explained
Linyb Geek Road
Linyb Geek Road
Nov 14, 2026 · R&D Management

Five Technical Chasms to Cross from Developer to Architect

This article outlines five major technical gaps developers must bridge to become architects: shifting from monolithic to distributed thinking, mastering system design over feature coding, evolving from solo work to team collaboration, aligning technology with business strategy, and adopting cloud-native DevOps practices.

Cloud NativeDevOpsKubernetes
0 likes · 17 min read
Five Technical Chasms to Cross from Developer to Architect
Software Engineering 3.0 Era
Software Engineering 3.0 Era
Nov 11, 2026 · Artificial Intelligence

AI Agents Execute Full Engineering Chain: Will Software Engineers Be Replaced?

An experiment using AI Agents to perform requirements, design, coding, and testing on a 3D printer firmware project shows Agents can handle multi-stage engineering tasks, but human judgment, review, and verification remain essential, shifting engineers toward system thinking, specification, and quality assurance rather than replacement.

AI agentsEngineering AutomationRequirements Engineering
0 likes · 19 min read
AI Agents Execute Full Engineering Chain: Will Software Engineers Be Replaced?
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Nov 3, 2026 · Backend Development

Vending Machine System Design: 5 Questions Before Coding, State Machine, Anti-Overselling & Power-Failure Recovery

This article provides a comprehensive system design for a vending machine, covering requirement clarification, state machine modeling, concurrency control for overselling prevention, payment idempotency, hardware fault tolerance with MQTT and WAL-based power failure recovery, and engineering best practices for offline sales and reconciliation.

IdempotencyIoTState Machine
0 likes · 34 min read
Vending Machine System Design: 5 Questions Before Coding, State Machine, Anti-Overselling & Power-Failure Recovery
Baobao Algorithm Notes
Baobao Algorithm Notes
Nov 1, 2026 · Artificial Intelligence

Super-Agent Design Philosophy: Organizing AI Workers to Liberate Human Attention

The article presents a Super-Agent architecture that separates a persistent Router layer from ephemeral Worker sessions, manages context via Inline/Spill caching and chain recall, uses speculative execution to hide latency, and applies exception-management principles to minimize human attention while maximizing autonomous task execution.

AI agent architectureContext ManagementRouter-Worker Pattern
0 likes · 15 min read
Super-Agent Design Philosophy: Organizing AI Workers to Liberate Human Attention
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 26, 2026 · Backend Development

Designing a Collaborative Document Editor: WebSocket, OT/CRDT & Snapshot Replay Deep Dive

This comprehensive guide covers designing a real-time collaborative document editing system, detailing WebSocket communication, OT/CRDT conflict resolution algorithms, server-side sequencing, snapshot-based storage, offline editing, presence, and performance optimization with runnable Java code examples.

CRDTDistributed SystemsJava
0 likes · 68 min read
Designing a Collaborative Document Editor: WebSocket, OT/CRDT & Snapshot Replay Deep Dive
dbaplus Community
dbaplus Community
Oct 24, 2026 · Backend Development

System Design: Building a Scalable URL Shortener from Requirements to Base62 Keys

This article walks through a system design interview for a URL shortener, covering requirements analysis, capacity estimation (20K read QPS, 15TB storage), API design, NoSQL data modeling, key generation via auto-increment ID with base62 encoding, hash-based partitioning, Redis caching with LRU eviction, load balancing strategies, and lazy expiration cleanup.

Redis cachingURL shortenerbase62 encoding
0 likes · 25 min read
System Design: Building a Scalable URL Shortener from Requirements to Base62 Keys
ITPUB
ITPUB
Oct 23, 2026 · R&D Management

What Is the Most Critical Skill for a Technical Lead? It's Not Technical Expertise

This article argues that the most important capability for a technical lead is not coding or architecture skill, but the ability to make correct decisions amid complex business, system, and organizational dynamics — defining direction, boundaries, and collaboration rules to manage complexity.

Decision Makingcareer transitioncomplexity management
0 likes · 7 min read
What Is the Most Critical Skill for a Technical Lead? It's Not Technical Expertise
Internet Backend Architecture Stack
Internet Backend Architecture Stack
Oct 22, 2026 · Backend Development

CQRS in Practice: Why It's Not Just Database Read/Write Separation — Domain Model Decoupling Costs & Red Lines

The article explains CQRS as domain model separation rather than database read/write splitting, detailing command/query model boundaries, event-driven synchronization challenges, consistency trade-offs, engineering pitfalls like event reliability and view explosion, when to avoid CQRS, and a reference e-commerce order implementation with consistency-based query routing.

CQRSarchitecture patternsconsistency models
0 likes · 15 min read
CQRS in Practice: Why It's Not Just Database Read/Write Separation — Domain Model Decoupling Costs & Red Lines
Cilantro Loves Linux
Cilantro Loves Linux
Oct 20, 2026 · Backend Development

Enterprise Core Architecture Design: 4 Case Studies & Layered Derivation Method

This article summarizes Chapter 13 of 'Architecture Fundamentals', presenting four enterprise system case studies—messaging platform, fund collection/payment, business monitoring, and regulatory reporting—to demonstrate a layered architecture derivation method covering functional architecture, service relationships, technical deployment, data design, and process flows, with practical checklists for responsibility, state visibility, failure recovery, and traceability.

Architecture DerivationDevOpsMessaging Platform
0 likes · 13 min read
Enterprise Core Architecture Design: 4 Case Studies & Layered Derivation Method
IT Architects Alliance
IT Architects Alliance
Oct 20, 2026 · Fundamentals

What Is Software Architecture? A Booking Example Shows How Components Collaborate

The article uses a meeting room booking system to illustrate software architecture, showing how dividing responsibilities between booking and notification modules, and choosing synchronous vs asynchronous collaboration, affects system behavior, user feedback, and implementation complexity, distinguishing architectural decisions from implementation details.

architectural decisionsbooking exampleimplementation complexity
0 likes · 5 min read
What Is Software Architecture? A Booking Example Shows How Components Collaborate
ITPUB
ITPUB
Oct 20, 2026 · Backend Development

Why WebSocket Broadcast Fails at 1M Viewers: Solving Massive Fan-Out in Live Chat

This article analyzes why naive WebSocket broadcast fails for million-viewer live chat due to bandwidth and client rendering limits, then presents a three-layer architecture with local fan-out, 100ms batching windows, priority-based sampling, and segmented sequence generation to reduce remote pushes from millions to dozens while maintaining perceived real-time experience.

Fan-outMessage BroadcastingNetty
0 likes · 21 min read
Why WebSocket Broadcast Fails at 1M Viewers: Solving Massive Fan-Out in Live Chat
Code Farming
Code Farming
Oct 18, 2026 · Backend Development

Four Mental Models to Deconstruct Financial Architecture

This article presents four reusable reasoning models for financial system architecture: phased FX cost optimization via netting, Boolean logic for regulatory boundary analysis, anemic vs rich domain model trade-offs for cross-module data transfer, and decomposing FX transactions into paired same-currency payments to simplify complex designs.

architectural thinkingdomain modelingdomain-driven design
0 likes · 9 min read
Four Mental Models to Deconstruct Financial Architecture
Ray's Galactic Tech
Ray's Galactic Tech
Oct 14, 2026 · Backend Development

From Chatbot to AI Agent: Why a Single While Loop Fails in Production

The article details the first week of the Aegis project, demonstrating why a naive while-loop agent loop fails in production and how to replace it with deterministic contracts, a finite state machine, bounded execution budgets, server-side tool authorization, and reproducible failure testing using local mocks.

AI agentBackend ArchitectureGo
0 likes · 25 min read
From Chatbot to AI Agent: Why a Single While Loop Fails in Production
Top Architect
Top Architect
Oct 13, 2026 · Backend Development

Snowflake ID Collision in Production: Why Custom ID Generators Fail

A production incident caused by a flawed custom Snowflake ID generator with a 31-bit timestamp (24-day cycle), IP-based BusinessId collisions, and unconfigured WorkerId/DataCenterId led to duplicate order IDs; the article analyzes the root causes and recommends mature libraries like Hutool and Baomidou with proper WorkerId assignment strategies.

Hutoolbackend developmentbaomidou
0 likes · 8 min read
Snowflake ID Collision in Production: Why Custom ID Generators Fail
Data Bricklaying Diary
Data Bricklaying Diary
Oct 13, 2026 · Backend Development

Why Your Agent Stuck at 'Processing': Designing Observable Task Status & Business Results

This article explains how to design observable Agent task statuses by distinguishing tasks, actions, and sessions; tracking execution phases, wait reasons, and action results; separating activity from real progress; and building task observation cards with evidence links for debugging and human handoff.

AgentBusiness ResultsDebugging
0 likes · 16 min read
Why Your Agent Stuck at 'Processing': Designing Observable Task Status & Business Results
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 12, 2026 · Backend Development

13 Years of Java Mastery: Free Knowledge Map for Backend Engineers

A Java engineer shares a free, comprehensive knowledge map built from 13 years in Beijing, covering nine modules including industrial project breakdowns, source code deep dives, algorithm patterns, AI integration, interview strategies, system design frameworks, and developer tools—all aimed at helping engineers move beyond CRUD and advance to architecture roles.

AI IntegrationAlgorithmsCareer Growth
0 likes · 33 min read
13 Years of Java Mastery: Free Knowledge Map for Backend Engineers
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Oct 11, 2026 · Backend Development

13 Years of Java Mastery: A Free Knowledge Map for Engineers

A Java engineer shares a free, comprehensive knowledge map built from 13 years in Beijing, covering nine modules including industrial projects, source code analysis, algorithm patterns, AI integration, interview strategies, system design, tools, and more, with practical methodologies and no paywalls.

AI IntegrationAlgorithmsJava
0 likes · 31 min read
13 Years of Java Mastery: A Free Knowledge Map for Engineers
Cilantro Loves Linux
Cilantro Loves Linux
Oct 9, 2026 · Backend Development

Four Principles of Large-Scale Internet Architecture: Availability, Scalability, Concurrency & Security Trade-offs

This chapter from "Architecture Fundamentals" defines four quality attributes — high availability, high scalability, high concurrency, and security — as the pillars of large-scale internet architecture, emphasizing that normal traffic tests only prove functional correctness, not resilience. It details the trade-offs between these attributes, concrete implementation patterns for each, and a practical checklist for deriving architecture from measurable business goals rather than stacking technologies.

Architecture PrinciplesDistributed SystemsHigh Availability
0 likes · 10 min read
Four Principles of Large-Scale Internet Architecture: Availability, Scalability, Concurrency & Security Trade-offs
Cilantro Loves Linux
Cilantro Loves Linux
Oct 8, 2026 · R&D Management

Why Experience Alone Doesn't Make an Architect: The Shift to System-Level Judgment

This article explores why years of coding experience don't automatically produce architect-level judgment, detailing the shift from local implementation to global abstraction, boundary setting, and trade-off decisions, and provides a four-step training loop with concrete daily practices and common pitfalls to avoid.

architect career planningarchitect vs programmerarchitecture training loop
0 likes · 9 min read
Why Experience Alone Doesn't Make an Architect: The Shift to System-Level Judgment
Xike
Xike
Oct 8, 2026 · Backend Development

Short Link Implementation: Core Algorithms, Base62 Encoding, and 302 Redirection

This article details the architecture of short link systems, covering short domain selection, unique ID generation strategies (auto-increment, Redis, Snowflake), Base62 and custom encoding, mapping storage with Redis and databases, 302 redirection flow, cache optimization, anti-enumeration, idempotency, expiration handling, multi-data-center deployment, and click tracking.

Redis cachingbase62http-redirection
0 likes · 15 min read
Short Link Implementation: Core Algorithms, Base62 Encoding, and 302 Redirection
Java Captain
Java Captain
Sep 30, 2026 · Interview Experience

WXG First-Round Interview: 60 Questions from Algorithms to Agent Design

A shared WXG first-round interview experience lists 60 questions covering self-introduction, algorithms (IP-to-uint64, linked-list folding, uniform sampling), system design, AI tools, large-model hallucinations, RAG, vector search, collaborative filtering, 12306 ticketing architecture, Redis internals, MySQL B+ trees, concurrency locks, and design patterns.

AlgorithmsB+ TreeConcurrency
0 likes · 7 min read
WXG First-Round Interview: 60 Questions from Algorithms to Agent Design
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 29, 2026 · Backend Development

10 System Design Questions That Decide Big Tech Interview Success

This article dissects 10 high-frequency system design questions — seckill, short URL, distributed ID, delayed tasks, leaderboard, real-time push, short-video feed, sharding, rate limiting, and config center — with architecture diagrams, core code, and comparative solutions for each.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 73 min read
10 System Design Questions That Decide Big Tech Interview Success
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 27, 2026 · Fundamentals

Complete Algorithm & Data Structure Interview Guide: From Arrays to Distributed Systems with Java Implementations

This comprehensive 30,000-word guide covers 9 core modules — data structures, sorting, search algorithms, algorithm paradigms, string algorithms, hash engineering, rate limiting, distributed IDs, and massive data processing — with Java code, complexity tables, and interview-focused explanations for big-tech preparation.

AlgorithmsData StructuresDatabase Indexing
0 likes · 76 min read
Complete Algorithm & Data Structure Interview Guide: From Arrays to Distributed Systems with Java Implementations
dbaplus Community
dbaplus Community
Sep 27, 2026 · Fundamentals

Why the Creators of Linux, Python, Redis, Nginx & SQLite Are True Geniuses

The article argues that creators of foundational software like Linux, Python, Redis, Nginx, and SQLite are true geniuses due to their exceptional abstraction skills and system-level boundary control, illustrated by real-world cases where their minimal, convergent designs outperform modern complex solutions, and warns that over-reliance on AI tools erodes deep system understanding essential for solving hard production issues.

AI-assisted codingLinuxNginx
0 likes · 14 min read
Why the Creators of Linux, Python, Redis, Nginx & SQLite Are True Geniuses
Ops Development & AI Practice
Ops Development & AI Practice
Sep 25, 2026 · Interview Experience

Why Production Heroes Fail Interviews: Converting Systemic Intuition into Architectural Proof

This article explains why experienced engineers who excel at real-world troubleshooting often struggle in technical interviews due to a structural mismatch between systemic debugging intuition and rote memorization tests, and provides a three-layer drill-down model plus a five-step diagnostic derivation framework to translate practical expertise into compelling architectural narratives that interviewers value.

architectural communicationcareer developmentinterview preparation
0 likes · 15 min read
Why Production Heroes Fail Interviews: Converting Systemic Intuition into Architectural Proof
Java Captain
Java Captain
Sep 25, 2026 · Backend Development

Tencent Architect's Decade of Insights: Simple, Evolvable Architecture Principles

A Tencent architect with nearly ten years experience shares principles for simple, evolvable architecture: modularization, layering, focusing on core business needs like QQ's social chat, avoiding premature optimization, service design with monitoring and canary releases, and code design with clear structure and single responsibility.

QQTencentcanary release
0 likes · 4 min read
Tencent Architect's Decade of Insights: Simple, Evolvable Architecture Principles
Ops Development & AI Practice
Ops Development & AI Practice
Sep 25, 2026 · Interview Experience

Forgetting Details ≠ Incompetence: Senior Engineers' Cognitive Compression Playbook

This article explains why senior engineers naturally forget micro-details through the brain's lossy compression, and provides a three-part framework — pre-interview 'deep-water nails' (real failure cases, core parameters, personal artifacts) and three on-the-spot defense frameworks (deduction, methodology anchoring, pivoting) — to demonstrate unforgeable engineering depth in high-stakes technical interviews.

Architecture ReviewDebuggingDistributed Systems
0 likes · 18 min read
Forgetting Details ≠ Incompetence: Senior Engineers' Cognitive Compression Playbook
Cloud Architecture
Cloud Architecture
Sep 24, 2026 · Backend Development

Scaling Spring Boot Sign-In to 100M Users: Distributed Architecture Evolution & Production Hardening

This article details the evolution of a Spring Boot daily sign-in system from 10K to 100M users, covering Redis bitmap sharding, Lua atomic operations, command outbox pattern, Kafka async reward processing, idempotency guarantees, fault tolerance strategies, and production-grade observability with real incident postmortems.

BitmapCommand OutboxDistributed Systems
0 likes · 36 min read
Scaling Spring Boot Sign-In to 100M Users: Distributed Architecture Evolution & Production Hardening
Data Bricklaying Diary
Data Bricklaying Diary
Sep 21, 2026 · Backend Development

Scaling Isn't Just Adding Instances: End-to-End Capacity, Traffic & Cost Design

This article argues that true system scaling requires end-to-end capacity planning across ingress, task processing, dependencies, and recovery—not merely adding instances—and shows how to translate business growth into workload models, manage backpressure, set per-link capacity budgets, validate with realistic load tests, and balance cost against performance.

Auto ScalingBackend Architecturebackpressure
0 likes · 24 min read
Scaling Isn't Just Adding Instances: End-to-End Capacity, Traffic & Cost Design
Weekly Large Model Application
Weekly Large Model Application
Sep 21, 2026 · Artificial Intelligence

Full-Duplex Voice Agents: When to Commit Parameters? Eager, Conservative, Two-Phase Compared

This article analyzes three commit strategies—Eager, Conservative, and Two-phase—for tool calling in full-duplex voice agents, explaining how each handles user self-correction, side-effect safety, and latency trade-offs, and provides selection guidelines based on operation reversibility.

Two-Phase Commitconservative commiteager commit
0 likes · 8 min read
Full-Duplex Voice Agents: When to Commit Parameters? Eager, Conservative, Two-Phase Compared
James' Growth Diary
James' Growth Diary
Sep 18, 2026 · Backend Development

Container Routing: Why the Same Agent Lands in Different Containers

This article details a four-step container routing mechanism (authentication, permission, routing, resolution) for an Agent platform, explaining how requests reach different container forms based on identity and instance health, and why distinguishing hard vs soft failures is critical for debugging.

Authenticationagent platformauthorization
0 likes · 27 min read
Container Routing: Why the Same Agent Lands in Different Containers
IT Services Circle
IT Services Circle
Sep 15, 2026 · Fundamentals

Why Linus Won't Put a National Anti-Fraud Center in the Linux Kernel

The article explains why integrating a national anti-fraud center into the Linux kernel violates core OS principles: kernels must remain neutral, minimal, and secure; adding application-specific logic with kernel-level privileges breaks least privilege, introduces instability, and undermines the open-source consensus that keeps Linux universal.

Least PrivilegeLinux kernelkernel architecture
0 likes · 8 min read
Why Linus Won't Put a National Anti-Fraud Center in the Linux Kernel
dbaplus Community
dbaplus Community
Sep 13, 2026 · R&D Management

Uber EM Reveals 14 Principles for System Design, Team Leadership & Career Transition

Uber engineering manager Sendil Nellaiyapen shares 14 hard-won principles covering system design foundations, scaling from thousands to millions, MVP trade-offs, clarity over seniority, avoiding experience traps, hypothesis-driven culture, latency misconceptions, guardrails for autonomy, and the mindset shift from engineer to manager.

MVPTeam LeadershipUber
0 likes · 24 min read
Uber EM Reveals 14 Principles for System Design, Team Leadership & Career Transition
Data Party THU
Data Party THU
Sep 13, 2026 · Artificial Intelligence

Agentic AI Systems: Reasoning Loops, Tools & Guardrails Explained

This article contrasts traditional RAG pipelines with agentic AI systems, detailing the four core components—orchestrator, tool calling, memory, and guardrails—and demonstrates how reasoning loops enable multi-step problem solving for system design interviews.

Agentic AIMemory ManagementOrchestrator
0 likes · 16 min read
Agentic AI Systems: Reasoning Loops, Tools & Guardrails Explained
TonyBai
TonyBai
Sep 13, 2026 · Backend Development

2 Engineers, AI, and a Rust Rewrite: Scaling OpenAI's Storage to 1B Users

OpenAI's Habitat storage system evolved from a Python library to a distributed platform handling 70M requests/second for 1B users, with engineers detailing scaling challenges, asyncio tuning, connection pool fixes, and a 2-engineer Rust rewrite using Codex and GPT-5.5 that boosted CPU efficiency 6x and memory efficiency 15x.

AI-assisted codingCodexConnection Pooling
0 likes · 26 min read
2 Engineers, AI, and a Rust Rewrite: Scaling OpenAI's Storage to 1B Users
Architect
Architect
Sep 12, 2026 · Artificial Intelligence

Google's Multi-Agent Research: Task Structure, Not Agent Count, Determines Architecture Value

Google's research on 260 multi-agent configurations across six benchmarks shows centralized architectures improve parallel tasks by 81% but hurt sequential planning by 39-70%. Teamwork framework adds critique-synthesis loops that retain failed branches. The key insight: agent count isn't an architecture metric—task decomposability, verifiable sub-results, and coordination costs should drive design.

AI agentsGoogle ResearchMulti-Agent Systems
0 likes · 18 min read
Google's Multi-Agent Research: Task Structure, Not Agent Count, Determines Architecture Value
TechVision Expert Circle
TechVision Expert Circle
Sep 9, 2026 · Industry Insights

AI Isn't Eliminating Tech Jobs—It's Quietly Compressing Headcount

In 2026, AI tools like Claude Code and GitHub Copilot Workspace are silently compressing junior tech roles by automating coding, testing, and ops tasks, reducing headcount needs while increasing workload for remaining engineers, making system design, incident judgment, and domain expertise the new irreplaceable skills.

AI-assisted developmentModel Context Protocolheadcount compression
0 likes · 13 min read
AI Isn't Eliminating Tech Jobs—It's Quietly Compressing Headcount
Data Bricklaying Diary
Data Bricklaying Diary
Sep 9, 2026 · Artificial Intelligence

Three Graphs, Three Jobs: Loop, Task Graph & Plugin Runtime in Agent Systems

This article argues that complex Agent systems must separate three distinct structures: Loop handles node-level convergence, Task Graph manages work dependencies and coordination, and Plugin Runtime binds capabilities like models and tools; mixing them into a monolithic Agent leads to invisible boundaries and unrecoverable failures.

Component GraphContextEvidence
0 likes · 17 min read
Three Graphs, Three Jobs: Loop, Task Graph & Plugin Runtime in Agent Systems
Code Farming
Code Farming
Sep 8, 2026 · Backend Development

QR Code Payments Decoded: 4 Systems, 6 Institutions, and the Async Architecture Behind Every Scan

This article breaks down the complete technical chain behind a QR code payment, revealing how authentication tokens, cross-bank clearing with central bank settlement, foreign exchange conversion, and asynchronous messaging systems work together to move money across institutions and currencies without synchronous responses.

QR code paymentasynchronous systemsclearing house
0 likes · 9 min read
QR Code Payments Decoded: 4 Systems, 6 Institutions, and the Async Architecture Behind Every Scan
Code Archaeology
Code Archaeology
Sep 7, 2026 · Fundamentals

Why C4 Starts with System Context Diagrams: A Step-by-Step Guide

This article explains why the C4 model begins with system context diagrams, detailing their purpose, key elements (people, software systems, relationships), notation conventions, and a step-by-step example of creating a context diagram for an online banking system integrating with core banking and email services.

C4 modelarchitecture documentationonline banking example
0 likes · 14 min read
Why C4 Starts with System Context Diagrams: A Step-by-Step Guide
Code Farming
Code Farming
Sep 7, 2026 · Backend Development

How Encyclopedia Systems Survive Data Center Fires: Architecture Deep Dive

This article breaks down the four-step architecture design of a high-concurrency encyclopedia system, covering latency-driven multi-data-center deployment, a five-layer request chain with caching at each level, a three-tier optimization pyramid, and master-slave synchronization with automatic failover for disaster recovery.

CDN cachingCanalGeoDNS
0 likes · 8 min read
How Encyclopedia Systems Survive Data Center Fires: Architecture Deep Dive
ITPUB
ITPUB
Sep 6, 2026 · Backend Development

How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing

WeChat avoids server crashes during midnight step-count resets for 1 billion users by using logical time-based versioning instead of physical updates, a custom PaxosStore for atomic increments, delayed double-write buffers for clock skew, Redis ZSet sharding for rankings, and asynchronous cold-data archival during low-traffic hours.

Distributed SystemsPaxosStoreRedis
0 likes · 18 min read
How WeChat Resets 1 Billion Step Counts at Midnight Without Crashing
James' Growth Diary
James' Growth Diary
Sep 5, 2026 · Artificial Intelligence

Why Build Your Own Agent: From Chat to Reliable Execution

This article argues that chat APIs alone are insufficient for AI agents; true agent systems require execution environments, tool loops, multi-tenant isolation, and layered architecture to move from demo to production-grade reliability across multiple entry points.

AI agentsLayered ArchitectureMulti-tenancy
0 likes · 22 min read
Why Build Your Own Agent: From Chat to Reliable Execution
Design Hub
Design Hub
Sep 1, 2026 · Artificial Intelligence

How to Build an AI Agent That Won’t Fall Apart with Harness Engineering

The article explains that AI agents often fail because they lack a reliable runtime environment—called a Harness—and outlines a systematic Harness Engineering approach, including seven core responsibilities, a practical checklist, and concrete examples to turn failures into reusable infrastructure.

AI agentsAgent Reliabilityharness engineering
0 likes · 19 min read
How to Build an AI Agent That Won’t Fall Apart with Harness Engineering
DeepNoMind
DeepNoMind
Aug 30, 2026 · Interview Experience

System Design Interview Prep: 7 Resources & a 7-Week Roadmap to Offer

This article outlines a structured 7-week preparation plan for system design interviews, recommending seven key resources — from foundational primers to real-world case studies — and emphasizes deliberate practice over passive video consumption to master trade-off reasoning under pressure.

7-week planAlex XuByteByteGo
0 likes · 12 min read
System Design Interview Prep: 7 Resources & a 7-Week Roadmap to Offer
dbaplus Community
dbaplus Community
Aug 23, 2026 · R&D Management

Why a “Big Mud Ball” Can Be a Good Architecture – Insights from a Former Google/AWS Architect

In this interview, former Google and AWS senior architect Gregor Hohpe explains that architects should amplify their teams rather than be the smartest, emphasizes risk reduction as the core value, advocates simplicity, visual thinking with paper and pen, warns against over‑reliance on AI, and shows how even a “big mud ball” can be a pragmatic architectural choice.

AI pitfallsleadershiprisk management
0 likes · 25 min read
Why a “Big Mud Ball” Can Be a Good Architecture – Insights from a Former Google/AWS Architect
samdeepthink
samdeepthink
Aug 23, 2026 · Databases

Is Splitting Data Across Machines Distributed? Understand Sharding vs Distributed Systems

The article explains that merely placing data on multiple machines constitutes sharding—a way to split data for capacity—but true distributed systems require coordinated nodes that communicate, replicate, and handle failures, illustrated with an e‑commerce warehouse analogy and guidance on choosing between sharding and distributed databases.

Distributed Systemsdatabase architectureselection criteria
0 likes · 8 min read
Is Splitting Data Across Machines Distributed? Understand Sharding vs Distributed Systems
samdeepthink
samdeepthink
Aug 21, 2026 · R&D Management

Why Architects Who Haven’t Coded in Years Miss Critical System Realities

The article explains how architects who stop writing or reading code lose essential insight into the system, leading them to suggest impractical solutions like a non‑existent message center, and offers concrete practices to stay connected with the codebase.

architecturecode reviewdevelopment practice
0 likes · 8 min read
Why Architects Who Haven’t Coded in Years Miss Critical System Realities
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 14, 2026 · Backend Development

API Flood Protection: Emergency Mitigation, Multi-Layer Defense & Rate Limiting Algorithms

This article provides a comprehensive guide to handling API abuse, covering emergency mitigation within three minutes, a multi-layer defense architecture, comparison of four rate limiting algorithms, practical implementations using Redis+Lua token bucket, Sentinel, and Guava Bloom filter, cache protection strategies, idempotency design, and a simulated interview scenario with code examples for distributed rate limiting and replay attack prevention.

API protectionBloom filterDistributed Systems
0 likes · 28 min read
API Flood Protection: Emergency Mitigation, Multi-Layer Defense & Rate Limiting Algorithms
Data Bricklaying Diary
Data Bricklaying Diary
Aug 11, 2026 · Artificial Intelligence

Three-Layer Ontology Intelligence: Separating Semantics, Decisions, and Actions

This article explains why ontology intelligence systems require a three-layer architecture—semantic layer for defining business meaning, decision layer for forming explainable action plans, and action layer for controlled state changes—with explicit handoff contracts to avoid mixing rules and side effects into prompts.

AI ArchitectureAction LayerDecision Layer
0 likes · 20 min read
Three-Layer Ontology Intelligence: Separating Semantics, Decisions, and Actions
Code Farming
Code Farming
Aug 9, 2026 · Backend Development

How a System Handles 30 Million Simultaneous Video Views

The article breaks down how QuickTok supports 30 million concurrent video streams by calculating QPS, storage and bandwidth needs, then applying HDFS with HBase indexing and aggressive CDN pre‑warming to shrink traffic from 88 Tbps to under 4 Tbps.

CDNHDFSVideo Streaming
0 likes · 5 min read
How a System Handles 30 Million Simultaneous Video Views
samdeepthink
samdeepthink
Aug 7, 2026 · Frontend Development

Why Backend Engineers Mistake Frontend for Simple—and What That Reveals

The article explains that backend engineers often view frontend work as easy because it changes rapidly with user preferences, while backend deals with stable, long‑standing challenges like data consistency, making each side complex in fundamentally different ways.

BackendComplexityUser Experience
0 likes · 4 min read
Why Backend Engineers Mistake Frontend for Simple—and What That Reveals
Code Farming
Code Farming
Aug 5, 2026 · Backend Development

How to Generate Billions of Conflict‑Free Short URLs

The article breaks down a real‑world architecture for a short‑URL service that must handle 12 billion entries and 40 k QPS, showing how to calculate capacity, compare generation algorithms, use Bloom filters for offline de‑duplication, and employ a three‑layer cache‑plus‑storage design to meet performance goals.

Bloom filterHBaseRedis
0 likes · 7 min read
How to Generate Billions of Conflict‑Free Short URLs
AI Engineer Programming
AI Engineer Programming
Aug 4, 2026 · Artificial Intelligence

Why Agents Call Unneeded Tools and How to Tackle It as a System‑Engineering Problem

The article defines tool hallucination in LLM agents, analyses training bias, context pollution, loop feedback and dialogue inertia as root causes, and proposes multi‑layer defenses—including visibility control, intent verification, runtime gating, architectural isolation, and feedback loops—framed as a system‑engineering challenge rather than mere prompt tweaking.

AgentLLMRuntime Guard
0 likes · 17 min read
Why Agents Call Unneeded Tools and How to Tackle It as a System‑Engineering Problem
Code Farming
Code Farming
Jul 30, 2026 · Backend Development

Can Your System Survive a Sudden 500K Live Viewers? 4 Proven Traffic‑Splitting Techniques

When a live broadcast suddenly attracts 500,000 viewers, the system faces 100,000 QPS likes and rapid reward transactions; this article breaks down a battle‑tested traffic‑splitting architecture—room‑based sharding, queue buffering, multi‑layer write caching, and consistent‑hash sharding—showing how each component controls load, ensures consistency, and enables seamless scaling.

consistent-hashingdistributed cachehigh concurrency
0 likes · 6 min read
Can Your System Survive a Sudden 500K Live Viewers? 4 Proven Traffic‑Splitting Techniques
samdeepthink
samdeepthink
Jul 25, 2026 · Backend Development

Do You Need Strong Coding Skills to Be an Effective Architect?

The author argues that, in most cases, a software architect must possess solid coding abilities because architecture decisions are validated through implementation, and without hands‑on coding the design often fails to meet real‑world constraints.

backend developmentcoding skillsmicroservices
0 likes · 4 min read
Do You Need Strong Coding Skills to Be an Effective Architect?
samdeepthink
samdeepthink
Jul 24, 2026 · Industry Insights

How Should Companies Hire Programmers in the AI Era?

The article argues that as AI takes over most business code, hiring will shift from pure coding tests to evaluating system‑design skills and the ability to collaborate with AI, emphasizing decision‑making over rote implementation.

AIAI collaborationinterview evolution
0 likes · 5 min read
How Should Companies Hire Programmers in the AI Era?
Liangxu Linux
Liangxu Linux
Jul 22, 2026 · Interview Experience

Top Embedded Engineer Interview Questions Every Interviewer Should Ask

This article outlines the essential embedded‑engineer interview questions—covering pointers, memory management, interrupts, peripheral protocols, debugging strategies, and system design—while explaining the reasoning behind each question and what answers reveal about a candidate's depth of knowledge.

C languageDebuggingEmbedded
0 likes · 8 min read
Top Embedded Engineer Interview Questions Every Interviewer Should Ask
samdeepthink
samdeepthink
Jul 22, 2026 · Backend Development

Why You Should Minimize Local Cache Usage

The article argues that local caches add significant consistency and management complexity, so they should be avoided unless a genuine performance bottleneck exists, illustrating the point with real‑world promotion spikes, GC concerns, and careful off‑heap testing.

GCRediscaching
0 likes · 4 min read
Why You Should Minimize Local Cache Usage
Wu Shixiong's Large Model Academy
Wu Shixiong's Large Model Academy
Jul 21, 2026 · Artificial Intelligence

How to Decompose a Production‑Ready RAG System for Interview Success

The article outlines a production‑ready RAG architecture by separating offline ingestion and online query pipelines, detailing nine ingestion steps, online request flow, data storage responsibilities, failure‑handling, monitoring, and acceptance criteria, all illustrated with concrete examples and traceable state machines.

RAGfailure handlingmonitoring
0 likes · 29 min read
How to Decompose a Production‑Ready RAG System for Interview Success
Code Farming
Code Farming
Jul 20, 2026 · Backend Development

How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second

The article explains how using a message queue as a buffer, asynchronous processor, and decoupling layer enables flash‑sale systems to handle tens of thousands of orders per second, reducing database overload, cutting response time from 500 ms to 50 ms, and preventing cascade failures.

Asynchronous ProcessingDecouplingMessage Queue
0 likes · 5 min read
How a Message Queue Keeps Flash‑Sale Systems Stable Under 10k Orders per Second
Nightwalker Tech
Nightwalker Tech
Jul 20, 2026 · Artificial Intelligence

Designing Reliable AI Agents: From a Single Prompt to Stable Delivery

The article explains why treating complex AI agents as a single long prompt leads to instability, and proposes a reusable closed‑loop architecture—scheduler, planner, executor, evaluator, repairer, and finalizer—that makes agents explainable, recoverable, and safely deliverable in production.

AI agentClosed-loop Architectureevaluation
0 likes · 21 min read
Designing Reliable AI Agents: From a Single Prompt to Stable Delivery
Ray's Galactic Tech
Ray's Galactic Tech
Jul 19, 2026 · Artificial Intelligence

Why the Real Production Bottleneck for AI Agents Is the Harness, Not the Model

The article explains that when AI agents move from prototype to production, failures usually stem from the execution harness—issues like multi‑step orchestration, tool integration, context overflow, and lack of observability—rather than the underlying language model itself, and it provides a concrete seven‑layer framework (ETCLOVG) to diagnose and engineer a reliable harness.

AI agentsETCLOVGGovernance
0 likes · 32 min read
Why the Real Production Bottleneck for AI Agents Is the Harness, Not the Model
Data Bricklaying Diary
Data Bricklaying Diary
Jul 19, 2026 · R&D Management

AI Programming Era: Design Judgment Is the Real Scarcity, Not Code

The article argues that AI lowers code generation cost but amplifies the need for clear requirements, architecture, and verification; it advocates Spec-Driven Development (SDD) with controlled agents and test feedback loops, and shares a practical workflow separating design, implementation, and testing roles to ensure systems are correctly designed, implemented, and validated.

AI programmingLoop EngineeringSDD
0 likes · 20 min read
AI Programming Era: Design Judgment Is the Real Scarcity, Not Code
Random Bulletin
Random Bulletin
Jul 17, 2026 · Backend Development

Why Moving from Real‑Time to Batch Is Essential for Scaling to Tens of Millions QPS

Scaling a service from millions to tens of millions of queries per second fails not because of data size but due to per‑request fixed costs, and the article shows how batching aggregates these costs, dramatically boosts throughput, reduces latency, and introduces new challenges such as memory pressure and partial failures.

batch processinghigh QPSlatency tradeoff
0 likes · 17 min read
Why Moving from Real‑Time to Batch Is Essential for Scaling to Tens of Millions QPS
YiSu Grain
YiSu Grain
Jul 16, 2026 · Fundamentals

Why One Architecture Diagram Isn’t Enough? Using the 4+1 View Model to Clarify a System

The article explains that a single diagram cannot capture all concerns of an internet‑hospital system, so architects should employ multiple viewpoints—logical, process, development, physical, and a scenario (+1) view—each tailored to different stakeholder needs and validated together.

4+1 view modelarchitecture documentationsoftware architecture
0 likes · 11 min read
Why One Architecture Diagram Isn’t Enough? Using the 4+1 View Model to Clarify a System
Infinite Tech Management
Infinite Tech Management
Jul 15, 2026 · R&D Management

Practical Guide to Drawing Architecture Diagrams: Using an AI Customer Service System as an Example

This article walks through a step‑by‑step method for creating a technical architecture diagram of an AI‑powered customer service system, covering how to identify the core business flow, map states and data ownership, decide sync/async boundaries, place modules, and annotate risks and support capabilities.

AI chatbotArchitecture DiagramState Machine
0 likes · 18 min read
Practical Guide to Drawing Architecture Diagrams: Using an AI Customer Service System as an Example
YiSu Grain
YiSu Grain
Jul 15, 2026 · R&D Management

From Tech Terms to Real Architecture Design: Day22‑Day42 Learning Roadmap

After completing the first 21 days of foundational topics, the second stage (Day22‑Day42) shifts focus to core architecture design, covering stakeholders, requirements, trade‑offs, evaluation methods, and a detailed daily syllabus that guides learners from theory to practical system design.

Learning Roadmaparchitecture evaluationquality attributes
0 likes · 12 min read
From Tech Terms to Real Architecture Design: Day22‑Day42 Learning Roadmap
Code Farming
Code Farming
Jul 13, 2026 · Backend Development

Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests

The article explains how to prevent system crashes during massive traffic spikes by applying three core techniques—rate limiting, circuit breaking, and graceful degradation—detailing algorithm choices, state machines, and practical implementation steps for high‑concurrency back‑end services.

Backendcircuit breakerdegradation
0 likes · 6 min read
Mastering Traffic Control: Keeping Systems Stable Under a Million Concurrent Requests
CTO Full-Stack Academy
CTO Full-Stack Academy
Jul 11, 2026 · Operations

Designing a Universal OMS: End‑to‑End Order Management Architecture

This article presents a comprehensive, industry‑agnostic design for a universal Order Management System (OMS), detailing its four core goals, complete order lifecycle flow, layered architecture with four‑level functional modules, implementation steps, and practical solutions to common deployment challenges.

OMSRisk ControlWorkflow Automation
0 likes · 22 min read
Designing a Universal OMS: End‑to‑End Order Management Architecture
samdeepthink
samdeepthink
Jul 10, 2026 · R&D Management

Why I Proactively Gave a Young Engineer a Raise and Promotion

Over two years I promoted a junior developer to mid‑level, raised his salary, and increased his bonus after he consistently delivered clean DDD‑styled code, handled simple tasks flawlessly, proactively addressed third‑party integration challenges, and demonstrated the ability to take on greater responsibility, illustrating the true criteria leaders use for advancement.

Career GrowthDDDcode quality
0 likes · 8 min read
Why I Proactively Gave a Young Engineer a Raise and Promotion
IT Learning Made Simple
IT Learning Made Simple
Jul 9, 2026 · Fundamentals

Master System Permissions and Boundary Architecture by Analyzing a Popular Family Drama

The article uses the plot of the viral family series ‘Researcher’s Daughter‑in‑Law Fixes the Toxic Relatives’ to illustrate core IT concepts such as three‑tier B/S architecture, the principle of least privilege, permission‑fuse mechanisms, and network boundary isolation, helping beginners grasp these topics without code.

IT educationLeast PrivilegePermission Management
0 likes · 7 min read
Master System Permissions and Boundary Architecture by Analyzing a Popular Family Drama
AI Illustrated Series
AI Illustrated Series
Jul 8, 2026 · Interview Experience

How to Design a Multi‑Agent Collaborative Office Assistant System

The article outlines a practical interview‑style design for a multi‑agent office assistant, detailing role specialization, task allocation flow, three communication patterns, conflict‑resolution strategies, and concrete usage scenarios such as meeting scheduling, weekly reporting, and sales data analysis.

communication patternsconflict resolutionmulti-agent
0 likes · 5 min read
How to Design a Multi‑Agent Collaborative Office Assistant System
Linyb Geek Road
Linyb Geek Road
Jul 3, 2026 · Artificial Intelligence

Production-Ready AI Agent Harness: Architecture and Design Principles

The article explains why the stability of AI agents depends on the harness rather than the model, outlines a five‑layer production‑grade harness architecture (Environment, Tool, Control, Memory, Evaluation), and presents five engineering principles to build a reliable, observable, and maintainable agent runtime system.

AI agentMemory Managementharness engineering
0 likes · 18 min read
Production-Ready AI Agent Harness: Architecture and Design Principles
Subtle Storm
Subtle Storm
Jul 2, 2026 · R&D Management

How to Gracefully Transition from Programmer to Architect

The article explains that moving from programmer to architect requires shifting focus from isolated code elegance to system‑wide thinking, mastering trade‑offs, learning from production incidents, broadening technical breadth, and communicating designs in business terms, offering a step‑by‑step roadmap for the transition.

career developmentcommunicationincident learning
0 likes · 6 min read
How to Gracefully Transition from Programmer to Architect
IT Learning Made Simple
IT Learning Made Simple
Jul 2, 2026 · Operations

Process View: The Heartbeat of System Runtime

The article explains the process view, which reveals how a system operates at runtime, covering processes, threads, inter‑process communication, concurrency models, synchronization mechanisms, performance indicators, and design principles, illustrated with diagrams and a concrete e‑commerce case study.

ConcurrencyIPCThread
0 likes · 9 min read
Process View: The Heartbeat of System Runtime
Thought Artisan
Thought Artisan
Jun 23, 2026 · Fundamentals

First Principles Design: How Top Engineers Rethink System Architecture

This article compiles first-principles design philosophies from ten software engineering leaders, including LLVM creator Chris Lattner and Perfetto expert Lalit Maganti, showing how to break problems to fundamental constraints rather than copying existing solutions.

Chris LattnerLLVMdomain-driven design
0 likes · 15 min read
First Principles Design: How Top Engineers Rethink System Architecture
Software Engineering 3.0 Era
Software Engineering 3.0 Era
Jun 21, 2026 · Fundamentals

What Is the First Principle of Software Engineering and Why It Matters

The article explains that software engineering’s recurring problems stem from three inherent contradictions—state‑space explosion versus human cognition, inevitable iteration versus entropy, and collective production versus information loss—and presents a four‑layer failure model and a concrete first‑principle framework to guide sustainable system design, even in the AI era.

AI toolscomplexity managementfirst principles
0 likes · 14 min read
What Is the First Principle of Software Engineering and Why It Matters
IT Learning Made Simple
IT Learning Made Simple
Jun 21, 2026 · Fundamentals

Step-by-Step Guide to Creating Your First Architecture Diagram

This tutorial walks you through why beginners struggle with blank canvases, how to define the diagram’s purpose, gather system details, use common shapes and connectors, and build a complete e‑commerce architecture diagram in Draw.io while avoiding common pitfalls.

Architecture DiagramBest Practicesdiagramming tutorial
0 likes · 7 min read
Step-by-Step Guide to Creating Your First Architecture Diagram
Hacker Afternoon Tea
Hacker Afternoon Tea
Jun 20, 2026 · Artificial Intelligence

How Multica Turns 2 People and 10 Agents into the Output of a 20‑Person Team

Multica treats AI agents as colleagues rather than tools, running them on users' machines while the server only stores data, queues tasks, and broadcasts events, and uses a four‑layer frontend, dual data streams, and a set of core modules to let a small team manage dozens of agents with real‑time visibility and measurable productivity.

AI agentsAgent OrchestrationGo backend
0 likes · 12 min read
How Multica Turns 2 People and 10 Agents into the Output of a 20‑Person Team
JavaGuide
JavaGuide
Jun 18, 2026 · Artificial Intelligence

From AI Coding to Full‑Stack AI Apps: Master Claude, Codex, Agents, and Skills

AIGuide is a free, open‑source handbook that walks Java, Go, frontend, testing, and architecture professionals through the entire AI application development lifecycle—from LLM fundamentals and RAG to agents, system design, and practical AI‑assisted coding—providing real‑world scenarios, key parameters, pitfalls, and interview preparation.

AI agentsAI application developmentLLM
0 likes · 14 min read
From AI Coding to Full‑Stack AI Apps: Master Claude, Codex, Agents, and Skills
Subtle Storm
Subtle Storm
Jun 15, 2026 · Backend Development

Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems

The article breaks down how caching reduces repeated slow‑resource access, rate limiting protects systems from overload, smoothing (peak shaving) buffers burst traffic with queues, and idempotency prevents duplicate operations, using a milk‑tea shop analogy to illustrate each technique’s role in high‑concurrency environments.

BackendIdempotencyPeak Shaving
0 likes · 7 min read
Caching, Rate Limiting, Smoothing, and Idempotency: Solving Concurrency Problems
Chen Tian Universe
Chen Tian Universe
Jun 15, 2026 · Operations

Ready‑to‑Use Settlement System Design Cases: 7 Real‑World Examples

This article presents a reusable 10‑step framework for designing settlement systems and showcases seven detailed real‑world case studies—including enterprise welfare, government services, promotion platforms, bank acquiring, points e‑commerce, highway ETC, and consumer finance—illustrating data sources, settlement flows, rule configuration, document design, and integration points.

Payment Processingcase studyfintech
0 likes · 35 min read
Ready‑to‑Use Settlement System Design Cases: 7 Real‑World Examples
IT Learning Made Simple
IT Learning Made Simple
Jun 8, 2026 · R&D Management

The Essential Gear to Become a Software Architect

This guide maps the complete skill tree for aspiring software architects, detailing foundational knowledge, core competencies such as system design and performance tuning, extended expertise in cloud‑native and big‑data technologies, and a staged learning roadmap to help newcomers acquire the necessary gear.

Cloud NativePerformance Optimizationbig data
0 likes · 9 min read
The Essential Gear to Become a Software Architect
AI Engineer Programming
AI Engineer Programming
Jun 8, 2026 · Artificial Intelligence

When to Use Small Models: A System Design Perspective

Small models are chosen based on deployment constraints rather than absolute parameter counts; the article outlines how resource limits, latency, cost, privacy, and task characteristics define their suitability, compares their strengths and weaknesses to large models, and offers system‑level design patterns for effective use.

LLM DeploymentRAGinference optimization
0 likes · 20 min read
When to Use Small Models: A System Design Perspective
IT Learning Made Simple
IT Learning Made Simple
Jun 7, 2026 · Industry Insights

A Day in the Life of an Architect: Meetings, Diagrams, and Taking the Blame

The article walks through a typical software architect’s day—from early‑morning stand‑ups and requirement reviews, through writing design documents, ad‑hoc incident triage, architecture review meetings, code reviews, and technical‑debt cleanup—highlighting time allocation, required skills, pain points, and practical advice for aspiring architects.

Architecture Designcareer advicecode review
0 likes · 9 min read
A Day in the Life of an Architect: Meetings, Diagrams, and Taking the Blame
Architectural Methodology
Architectural Methodology
Jun 5, 2026 · Interview Experience

How to Ace Architecture Interview Questions with Structured Thinking

The article explains that unlike developer interviews, architecture interviews focus on structured thinking, problem decomposition, and communication, and provides a step‑by‑step framework—break the problem, layer the design, weigh trade‑offs, and use a STAR‑plus‑technical format—along with concrete examples and common pitfalls to avoid.

DDDSTAR methodarchitecture interview
0 likes · 7 min read
How to Ace Architecture Interview Questions with Structured Thinking
IT Learning Made Simple
IT Learning Made Simple
Jun 3, 2026 · R&D Management

From Debugging Bugs to Designing Architecture: My 10‑Year Engineer Journey

The author recounts a decade‑long evolution from writing simple CRUD code and fixing login bugs to leading system architecture design, highlighting the shifting mindset, key learning milestones, and practical advice for developers seeking to grow beyond code to strategic engineering roles.

career developmentsoftware architecturesoftware engineering
0 likes · 8 min read
From Debugging Bugs to Designing Architecture: My 10‑Year Engineer Journey
IT Learning Made Simple
IT Learning Made Simple
Jun 2, 2026 · R&D Management

What Exactly Does a Software Architect Do? The Role That Involves More PPTs Than Coding

The article demystifies the software architect role by outlining core duties such as system design, technology selection, solving technical challenges, cross‑team coordination, a typical daily schedule, and how it differs from senior developers, while emphasizing that architects are not omnipotent but facilitators.

role comparisonsoftware architecturesystem design
0 likes · 8 min read
What Exactly Does a Software Architect Do? The Role That Involves More PPTs Than Coding