In a world overflowing with frameworks, tools, and buzzwords, software architecture can feel overwhelmingly complex—especially if you’re just starting out or if you’ve been in the game long enough to need a refresher. Recently, I watched an excellent talk by Jerry Nixon, a veteran Microsoft field engineer with 14 years of experience, titled “Modern Architecture 101 for New Engineers & Forgetful Experts” (delivered at NDC Copenhagen 2025). It cuts through the noise and gets back to fundamentals. Drawing heavily from his insights, here’s my take on building robust enterprise architectures without overcomplicating things.
Why “Best Practices” Aren’t Always Best
One of the first things Jerry hammers home is skepticism toward the phrase “best practices.” It sounds authoritative, but it often hides a lack of real reasoning. What works for a massive corporation with unlimited budget and talent might cripple a smaller team. Architecture isn’t one-size-fits-all—it’s deeply contextual.
Consider company politics, budget constraints, team expertise, and long-term maintainability. Large enterprises can afford experimental mistakes; startups often can’t. The evolution of architecture reflects this: from monolithic spaghetti code in the 90s, to layered n-tier apps in the 2000s, to microservices dominance in the 2010s. None of these are obsolete; the right choice depends on your needs.
The Architect’s True Role: Champion of Simplicity
Architects make the most expensive decisions—the ones hardest to reverse later. Your job isn’t to include every shiny new tool; it’s to decide what to exclude. Complexity is the enemy. As Jerry puts it: Simplicity is the best architecture.
You’ll decide on everything from source control and CI/CD pipelines to cloud providers, containers, serverless functions, programming languages, frontend frameworks, databases, AI integrations, telemetry, accessibility, and more. But every addition must be justified. Ask: Does this solve a real problem? Can we live without it?
Building a Typical Enterprise Architecture: Layer by Layer
Let’s break down a modern enterprise system piece by piece, focusing on common problems like scalability, security, integration, and maintainability.
1. The Core Triangle: Client → API → Database
Never let clients talk directly to the database. This leaks schema details, tightly couples components, and creates security nightmares. Always insert an API layer to abstract the data store.
Pro tip: Colocate your API with the database when possible—it eliminates network driver issues and simplifies deployment.
2. Separate Reads from Writes (CQRS)
High-traffic apps often have far more reads than writes. Use Command Query Responsibility Segregation (CQRS) to split them. This allows independent scaling: beef up read capacity without touching writes, reducing contention.
Pair this with database read replicas to offload queries. Accept eventual consistency—data syncs in milliseconds, not instantly, but that’s usually fine for most scenarios.
3. Decouple Services with Messaging
For inter-service communication, introduce a service bus or message queue. It handles retries, dead-letter queues for failed messages, and asynchronous processing.
Add queues for background jobs (e.g., email sending, image processing) to keep the user experience snappy. If something fails transiently, retry automatically.
For real-time needs, use event hubs or streaming platforms. This enables reactive UIs—push updates to clients without constant polling.
4. Manage APIs Properly
Route traffic through an API gateway/manager. It handles versioning, load balancing, authentication, rate limiting, and monitoring in one place.
5. Cache Aggressively
Reduce database hits with:
- Level 1: In-memory caching (fastest, local to the app).
- Level 2: Distributed caching (e.g., Redis) for shared access across instances.
6. Optimize Content and Data Delivery
Serve static assets (images, JS, CSS) via CDNs for global low-latency delivery.
For databases:
- Column stores for fast analytics.
- Hash tables or in-memory tables for blazing writes/queries.
- Graph databases for complex relationships.
- NoSQL for schema-flexible data.
7. Modern Additions
- AI Integration: Call remote models via secured API gateways—don’t embed them everywhere.
- Offline Support: Queue requests and cache responses for mobile/web apps.
- Data Lakes & Analytics: Centralize raw data for machine learning; feed insights back into the app.
- Security First: Use centralized identity providers (e.g., Azure Entra ID) for JWT-based auth and role-based access.
Final Thoughts: Keep It Simple
The overwhelming array of choices today can paralyze teams. But great architecture boils down to understanding each component’s purpose and justifying its place. Start minimal, add only when necessary, and always prioritize maintainability and user experience.
Jerry’s talk is a fantastic reminder that experience matters—learn from others’ mistakes to avoid repeating them. If you’re building enterprise software, watch the original here for the full depth (and his entertaining delivery).
What’s your biggest architecture headache right now? Drop a comment—I’d love to hear!
Inspired by Jerry Nixon’s NDC Copenhagen 2025 talk.
