Skip to content

Software Architecture

Navigation

Jump to content ↓

Home
Overview
About

Styles

Index
Architecture Styles
Event-Driven Architecture
Layered Architecture
Microkernel Architecture
Microservices Architecture
Modular Monolith Architecture
Orchestration-Driven Service-Oriented Architecture (SOA)
Pipeline Architecture
Ports and Adapters (Hexagonal Architecture)
Service-Based Architecture
Space-Based Architecture

Concepts

Distributed

Index
Backpressure
Broadcast Protocols
Caching
CAP Theorem
Consensus Algorithms
Consistency Models
Content Delivery Networks (CDNs)
Control Plane / Data Plane
CRDTs (Conflict-free Replicated Data Types)
Distributed Transactions
DNS (Domain Name System)
Failure Detection
Fallacies of Distributed Computing
HTTP
Idempotency
Leader Election
Load Balancing
Logical Clocks
Partitioning
Queueing Theory for Architects
Rate Limiting and Upstream Resiliency
Replication
Scalability
Serverless Computing
System Models
TLS (Transport Layer Security)

Operations

Index
Automation
Availability
Chaos Engineering
Common Failure Causes
Data Integrity
Error Budgets
Incident Management
Manageability
Monitoring
Observability
Site Reliability Engineering
Testing for Reliability

Patterns

Index
Anticorruption Layer (ACL)
Branch by Abstraction
Bulkhead Pattern
Business Logic Implementation Patterns
Circuit Breaker
Context Map and Bounded Context Integration Patterns
Domain Model Pattern
MVC and Web Presentation Patterns
Outbox Pattern
Parallel Run
Progressive Delivery
Repository Pattern
Retry
Saga Pattern
Sidecar / Service Mesh
Specification Pattern
Strangler Fig Pattern
Timeout

Databases

Index
Data Models
Encoding and Evolution
Object-Relational Mapping Patterns
Storage Engines
Transactions

Streams

Index
Batch Processing
Change Data Capture
Event Sourcing and CQRS
Stream Processing

Comparisons

Index
API Protocol Selection: REST vs gRPC vs GraphQL
Architecture Styles Comparison
Build vs Buy vs Adopt (Open-Source)
Consistency Model Selection
Cost vs Availability Decision Guide
Decomposition Strategy: How Far to Break Up a System
Migration Pattern Selection
Orchestration vs Choreography
Performance and Capacity Decision Guide
Stability Pattern Selection
Synchronous vs Asynchronous Communication

Reference

Index
Technology Glossary

Sources

Index
A Philosophy of Software Design
Accelerate: The Science of Lean Software and DevOps
AI Engineering
Building Event-Driven Microservices
Building Evolutionary Architectures
Chaos Engineering: System Resiliency in Practice
Designing Data-Intensive Applications
Designing Machine Learning Systems
Domain-Driven Design: Tackling Complexity in the Heart of Software
Enterprise Integration Patterns
Foundations of Scalable Systems
Fundamentals of Software Architecture
Learning Domain-Driven Design
Mastering API Architecture
Monolith to Microservices
Patterns of Enterprise Application Architecture
Release It! Design and Deploy Production-Ready Software
Reliable Machine Learning
Site Reliability Engineering
Software Architecture Metrics
Software Architecture Patterns
Software Architecture: The Hard Parts
Team Topologies: Organising Business and Technology Teams for Fast Flow
Understanding Distributed Systems

Authors

Software Architecture › Tags › Pipeline

Pipeline

1 page

Pipeline Architecture style
Filter-and-pipe; technically partitioned; ETL/data processing; EIP treats Pipes and Filters as a messaging composition pattern

A personal knowledge base synthesised from key books in the field. GitHub · Feedback & suggestions