Skip to main content
← All Tags

Software architecture

96 articles in this category (Page 4 of 4)

Software architecturePerformanceInfrastructure

CDNs, make the world feel closer

How CDNs improve performance and reliability: caching strategies, configuration tips, purge practices, and cost considerations.

Read more
Software architectureDatabasesArchitecture

Choosing a database, practicality over purity

Practical guidance to choose the right database for your needs: relational, key-value, document, column-family, graph, and NewSQL trade-offs.

Read more
Software architectureDatabasesOperations

Database replication, how to copy reliably and why it matters

Overview of replication modes, when to use synchronous vs asynchronous replication, and operational practices for reliable failover and scaling.

Read more
Software architectureDatabasesArchitecture

Database sharding, splitting data without losing your mind

A practical look at sharding strategies, design trade-offs, rebalancing, and operational tips for partitioning large datasets.

Read more
Software architectureSystem designArchitecture

Horizontal scaling, building systems that grow outwards

Practical guidance for scaling out by adding nodes, autoscaling flow, orchestration tips, and common pitfalls to avoid.

Read more
Software architectureNetworkingSystem design

Load balancers, the traffic cops of your architecture

Overview of load balancer types, trade-offs between L4 and L7, operational best practices, and deployment recommendations.

Read more
Software architectureSoftware designSystem design

Massively scaling a web application

A complete guide to scaling web applications from a single server to multi-region deployments. Covers vertical and horizontal scaling, load balancing, database sharding, caching, CDNs and more.

Read more
Software architectureArchitectureOperations

Multi-region deployment, global availability with local complexity

Guidance for running services across multiple regions: patterns for routing, data strategies, failover testing, and compliance considerations.

Read more
Software architectureSystem designOperations

Single server setup, when simple is best

Practical guide to single-server deployments: minimal ops, backups, monitoring, and safe evolution strategies for small teams and prototypes.

Read more
Software architectureSystem designArchitecture

Stateful vs Stateless, design choices that shape scalability

Compare stateful and stateless architectures, trade-offs for scaling, operational patterns, and practical techniques for managing state.

Read more
Software architectureSystem designArchitecture

Vertical scaling, when you need raw power

When to scale up a single machine, practical tuning tips for CPU, memory, and storage, and operational cautions for large-instance deployments.

Read more
Software architectureMicroservicesDesign patterns

Microservices Design Patterns: Best Practices for Scalable Systems

Comprehensive guide to microservices design patterns including API Gateway, Circuit Breaker, Saga, and CQRS. Learn proven patterns for building resilient, scalable distributed systems.

Read more
AI NewsSoftware ArchitectureFrontend Development

The Ideal Micro-Frontends Platform

Luca Mezzalira explains micro-frontends as a strategy to scale frontend architecture and organization. Learn the four key architectural decisions (Identify, Compose, Route, Communicate) and the necessity of a Platform Team and Developer Experience.

Read more
AI NewsArchitecture & DesignSoftware Architecture

Three Questions That Help You Build a Better Software Architecture

This article outlines three critical questions teams should answer when architecting a Minimum Viable Architecture (MVA) for an MVP: Is the business idea worth pursuing?, How much performance and scalability are needed?, and How much maintainability and supportability are required? It emphasizes the importance of empiricism and iterative development in making these decisions.

Read more
Software architectureSoftware designSOLID

SOLID

Complete guide to SOLID principles in object-oriented programming. Learn Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion with practical examples.

Read more
Software architectureSoftware designSOLID

D (Dependency Inversion) from SOLID

Understand the Dependency Inversion Principle from SOLID. Learn why high-level modules should depend on abstractions, not concrete implementations, and how DIP enables testable, flexible architecture.

Read more
Software architectureSoftware designSOLID

I (Interface Segregation) from SOLID

Learn the Interface Segregation Principle from SOLID. Discover why fat interfaces force unnecessary dependencies and how to design focused, client-specific interfaces.

Read more
Software architectureSoftware designSOLID

L (Liskov Substitution) from SOLID

Understand the Liskov Substitution Principle from SOLID. Learn why subclasses must be substitutable for their parent classes and how violations lead to subtle bugs in inheritance hierarchies.

Read more
Software architectureSoftware designSOLID

O (Open/Closed) from SOLID

Master the Open/Closed Principle from SOLID. Learn how to design software that is open for extension but closed for modification, so new features don't break existing code.

Read more
Software architectureSoftware designSOLID

S (Single Responsibility) from SOLID

Understand the Single Responsibility Principle from SOLID. Learn why a class should have only one reason to change and how SRP leads to more maintainable, testable code.

Read more
Software designSoftware architecture

Microservices vs Monoliths

Comprehensive comparison of microservices and monolithic architectures. Learn when to use each approach, their benefits, trade-offs, and best practices for modern software development.

Read more
Software architectureSoftware designThoughts

Best Of: The Early History Of Smalltalk

Key quotes and insights from Alan Kay's paper on the early history of Smalltalk. Explores object-oriented programming origins, message passing, and the philosophy behind Smalltalk's design.

Read more
Software architectureSoftware designDomain-Driven Design

Hexagonal Architecture: Why Your Domain Logic Shouldn't Know About Your Database

Stop letting frameworks dictate your architecture. Learn how Hexagonal Architecture (Ports & Adapters) isolates business logic from infrastructure, makes testing trivial, and lets you swap databases without rewriting code.

Read more
Software architectureSoftware designDomain driven design

Anemic vs Rich Domain Models

Understand the difference between Anemic and Rich Domain Models in Domain-Driven Design. Learn which approach to choose for better code organization and where to put business logic.

Read more