Skip to main content
Mapagam

44 SECTIONS · 561 TOPICS

Microservices Roadmap

  1. Understanding Microservices Architecture

    1. 1. Understanding Microservices Principles
    2. 2. Comparing Monolithic vs Microservices Architecture
    3. 3. Understanding Service Boundaries
    4. 4. Understanding Microservices Benefits
    5. 5. Understanding Microservices Challenges
    6. 6. Understanding Service Independence
    7. 7. Understanding CAP Theorem
    8. 8. Applying Conway's Law
    9. 9. Understanding Bounded Contexts
    10. Example: "Customer" in different contexts
    11. 10. Understanding Service Granularity
    12. 11. Understanding Microservices vs SOA
    13. 12. Understanding Eventual Consistency Model

  2. Designing Service Boundaries

    1. 1. Applying Domain-Driven Design
    2. 2. Defining Bounded Contexts
    3. 3. Identifying Service Domains
    4. 4. Decomposing by Business Capability
    5. 5. Decomposing by Subdomain
    6. 6. Applying Single Responsibility Principle
    7. 7. Determining Service Granularity
    8. 8. Avoiding Distributed Monoliths
    9. 9. Using Database per Service Pattern
    10. 10. Managing Service Dependencies
    11. 11. Defining Aggregates and Entities
    12. Example: Order aggregate (Java 21)
    13. 12. Using Context Mapping Patterns

  3. Setting Up Development Environment

    1. 1. Installing Docker and Container Tools
    2. 2. Setting Up Local Service Registry
    3. 3. Configuring Service Mesh Locally
    4. 4. Setting Up Message Broker
    5. 5. Configuring API Gateway Locally
    6. 6. Using Docker Compose
    7. Example: docker-compose.yml for an order stack
    8. 7. Setting Up Local Kubernetes
    9. 8. Configuring Service Templates
    10. 9. Setting Up Database Containers
    11. 10. Implementing Hot Reload
    12. 11. Using Development Tools
    13. 12. Configuring Local Tracing

  4. Implementing RESTful APIs

    1. 1. Designing Resource-Based URLs
    2. 2. Using HTTP Methods Correctly
    3. 3. Implementing HTTP Status Codes
    4. 4. Designing Idempotent Operations
    5. Example: Idempotency-Key (Spring Boot 3)
    6. 5. Implementing Content Negotiation
    7. 6. Using HATEOAS Principles
    8. Example: HAL response
    9. 7. Implementing Pagination
    10. 8. Implementing Filtering and Sorting
    11. 9. Handling Partial Responses
    12. 10. Using ETags for Caching
    13. 11. Implementing Bulk Operations
    14. 12. Implementing Request/Response Compression

  5. Working with GraphQL APIs

    1. 1. Defining GraphQL Schemas
    2. Example: SDL
    3. 2. Implementing Queries
    4. 3. Implementing Mutations
    5. Example: Mutation with payload
    6. 4. Using Subscriptions
    7. 5. Implementing Resolvers
    8. Example: Resolver (Apollo Server 4)
    9. 6. Handling N+1 Query Problems
    10. Example: DataLoader
    11. 7. Using Fragments
    12. Example: Fragment
    13. 8. Implementing Pagination
    14. 9. Implementing Authentication
    15. 10. Handling Errors
    16. 11. Implementing Federation
    17. Example: Federated entity
    18. 12. Optimizing Query Performance

  6. Implementing gRPC Communication

    1. 1. Defining Protocol Buffers
    2. Example: order.proto
    3. 2. Generating Service Stubs
    4. 3. Implementing Unary RPCs
    5. Example: Unary server (Java)
    6. 4. Implementing Server Streaming
    7. 5. Implementing Client Streaming
    8. 6. Implementing Bidirectional Streaming
    9. 7. Using gRPC Metadata
    10. 8. Handling gRPC Errors
    11. 9. Implementing Deadlines and Timeouts
    12. 10. Using gRPC Interceptors
    13. 11. Implementing Load Balancing
    14. 12. Managing Protocol Buffer Versioning

  7. Managing Inter-Service Communication

    1. 1. Using Synchronous Communication
    2. 2. Using Asynchronous Communication
    3. 3. Implementing Request/Reply Pattern
    4. 4. Implementing Fire-and-Forget Pattern
    5. 5. Handling Service Timeouts
    6. 6. Implementing Retry Mechanisms
    7. Example: Resilience4j retry (Java)
    8. 7. Managing Connection Pooling
    9. 8. Using Service Mesh
    10. 9. Handling Partial Failures
    11. 10. Implementing Bulkheads
    12. 11. Understanding Communication Trade-offs
    13. Synchronous
    14. Asynchronous
    15. 12. Implementing Correlation ID Propagation

  8. Working with Message Brokers

    1. 1. Implementing Publish-Subscribe Pattern
    2. 2. Implementing Point-to-Point Pattern
    3. 3. Using Message Headers
    4. 4. Implementing Message Routing
    5. 5. Handling Message Acknowledgment
    6. 6. Implementing Dead Letter Queues
    7. 7. Using Message TTL
    8. 8. Implementing Message Ordering
    9. 9. Handling Poison Messages
    10. 10. Using Message Priority
    11. 11. Implementing Message Deduplication
    12. 12. Working with RabbitMQ, Kafka, AWS SQS/SNS

  9. Implementing Event-Driven Architecture

    1. 1. Designing Domain Events
    2. Example: CloudEvents-style domain event
    3. 2. Implementing Event Sourcing
    4. 3. Using Event Streams
    5. 4. Implementing Event Versioning
    6. 5. Handling Event Ordering
    7. 6. Implementing Event Replay
    8. 7. Using Event Schemas
    9. 8. Implementing Event Handlers
    10. 9. Handling Event Consistency
    11. Example: Outbox table
    12. 10. Using Event Correlation
    13. 11. Implementing Event Notification vs Event-Carried State Transfer
    14. Event Notification
    15. Event-Carried State Transfer
    16. 12. Managing Event Store

  10. Implementing CQRS Pattern

    1. 1. Understanding CQRS Principles
    2. 2. Separating Read and Write Models
    3. 3. Implementing Command Handlers
    4. Example: Command handler (Java)
    5. 4. Implementing Query Handlers
    6. 5. Synchronizing Read and Write Models
    7. 6. Implementing Event Sourcing with CQRS
    8. 7. Handling Eventual Consistency
    9. 8. Designing Read Model Projections
    10. 9. Optimizing Query Performance
    11. 10. Managing CQRS Complexity
    12. 11. Implementing Command Validation
    13. 12. Using Event-Driven Synchronization

  11. Implementing Service Discovery

    1. 1. Implementing Client-Side Discovery
    2. 2. Implementing Server-Side Discovery
    3. 3. Using Service Registry
    4. 4. Implementing Health Checks
    5. 5. Handling Service Registration
    6. 6. Using DNS-Based Discovery
    7. 7. Implementing Service Metadata
    8. 8. Handling Dynamic Port Allocation
    9. 9. Implementing Heartbeat Mechanisms
    10. 10. Managing Service Instances
    11. 11. Using Service Discovery Tools
    12. 12. Implementing Service Health Aggregation

  12. Implementing API Gateway

    1. 1. Routing Requests
    2. 2. Implementing Request Aggregation
    3. 3. Handling Protocol Translation
    4. 4. Implementing Rate Limiting
    5. 5. Managing Authentication
    6. 6. Implementing Request/Response Transformation
    7. 7. Handling API Versioning
    8. 8. Implementing Response Caching
    9. 9. Using Circuit Breakers
    10. 10. Implementing CORS Handling
    11. 11. Managing API Documentation
    12. 12. Implementing Backend for Frontends

  13. Implementing Service Mesh

    1. 1. Understanding Service Mesh Architecture
    2. 2. Using Sidecar Proxies
    3. 3. Implementing Traffic Management
    4. 4. Using Circuit Breaking
    5. 5. Implementing Load Balancing
    6. 6. Managing mTLS
    7. 7. Implementing Traffic Splitting
    8. Example: Istio canary 90/10
    9. 8. Using Fault Injection
    10. 9. Implementing Request Routing
    11. 10. Managing Service Policies
    12. 11. Implementing Observability
    13. 12. Comparing Istio vs Linkerd vs Consul Connect

  14. Managing Distributed Configuration

    1. 1. Externalizing Configuration
    2. 2. Using Configuration Server
    3. 3. Implementing Configuration Refresh
    4. 4. Managing Secrets
    5. 5. Using Environment Variables
    6. 6. Implementing Configuration Profiles
    7. 7. Versioning Configuration
    8. 8. Handling Configuration Hierarchy
    9. 9. Implementing Feature Flags
    10. 10. Using Configuration Encryption
    11. 11. Managing Configuration Schema
    12. 12. Using Configuration Management Tools

  15. Managing Distributed Data

    1. 1. Implementing Database per Service
    2. 2. Understanding Shared Database Anti-Pattern
    3. 3. Implementing Data Replication
    4. 4. Handling Data Consistency
    5. 5. Using Eventual Consistency
    6. 6. Implementing Change Data Capture
    7. 7. Managing Data Ownership
    8. 8. Handling Data Duplication
    9. 9. Implementing Polyglot Persistence
    10. 10. Implementing Database Sharding
    11. 11. Managing Data Migration
    12. 12. Understanding Transaction Boundaries

  16. Managing Distributed Transactions

    1. 1. Understanding ACID vs BASE Properties
    2. 2. Understanding Two-Phase Commit
    3. 3. Implementing Saga Pattern
    4. 4. Using Compensating Transactions
    5. 5. Implementing Saga Orchestration
    6. 6. Implementing Saga Choreography
    7. 7. Handling Transaction Isolation
    8. 8. Managing Transaction Timeouts
    9. 9. Implementing Idempotency
    10. 10. Using Event-Driven Consistency
    11. 11. Handling Partial Failures
    12. 12. Managing Transaction Logs

  17. Managing Data Consistency

    1. 1. Understanding Eventual Consistency
    2. 2. Implementing Strong Consistency
    3. 3. Using Causal Consistency
    4. 4. Implementing Read-Your-Writes Consistency
    5. 5. Using Optimistic Locking
    6. Example: version column
    7. 6. Implementing Pessimistic Locking
    8. 7. Using Idempotency for Safe Retries
    9. 8. Implementing Conflict Resolution
    10. 9. Managing Data Versioning
    11. 10. Understanding Consistency Trade-offs
    12. 11. Implementing Consistency Patterns
    13. 12. Using Consistency Levels

  18. Implementing Authentication and Authorization

    1. 1. Implementing JWT Authentication
    2. 2. Using OAuth 2.0 Flows
    3. 3. Implementing API Key Authentication
    4. 4. Using mTLS Authentication
    5. 5. Implementing Token Refresh
    6. 6. Managing Token Expiration
    7. 7. Implementing Role-Based Access Control
    8. 8. Implementing Attribute-Based Access Control
    9. Example: Rego policy
    10. 9. Using Claims-Based Authorization
    11. 10. Implementing Service-to-Service Auth
    12. 11. Handling Token Revocation
    13. 12. Implementing Single Sign-On

  19. Implementing Security Patterns

    1. 1. Encrypting Data in Transit
    2. 2. Encrypting Data at Rest
    3. 3. Implementing Input Validation
    4. 4. Preventing SQL Injection
    5. 5. Preventing XSS Attacks
    6. 6. Implementing CSRF Protection
    7. 7. Using Security Headers
    8. 8. Implementing Secrets Management
    9. 9. Handling Sensitive Data
    10. 10. Implementing Audit Logging
    11. 11. Using API Security Standards
    12. 12. Implementing Zero Trust Architecture

  20. Implementing Communication Security

    1. 1. Implementing TLS/SSL
    2. 2. Using mTLS
    3. 3. Implementing Certificate Management
    4. 4. Using Service-to-Service Authentication
    5. 5. Implementing API Gateway Security
    6. 6. Managing Network Policies
    7. Example: Kubernetes NetworkPolicy
    8. 7. Using VPN and Private Networks
    9. 8. Implementing Web Application Firewall
    10. 9. Managing DDoS Protection
    11. 10. Implementing IP Whitelisting/Blacklisting
    12. 11. Using Network Segmentation
    13. 12. Implementing Secure Service Mesh Communication

  21. Implementing Rate Limiting

    1. 1. Using Token Bucket Algorithm
    2. Example: Token bucket (Redis Lua)
    3. 2. Using Leaky Bucket Algorithm
    4. 3. Using Fixed Window Counter
    5. 4. Using Sliding Window Log
    6. 5. Using Sliding Window Counter
    7. 6. Implementing Per-User Limits
    8. 7. Implementing Per-Service Limits
    9. 8. Handling Rate Limit Responses
    10. 9. Using Distributed Rate Limiting
    11. 10. Implementing Rate Limit Headers
    12. 11. Managing Rate Limit Tiers
    13. 12. Implementing Adaptive Rate Limiting

  22. Implementing Service Resilience

    1. 1. Understanding Failure Modes
    2. 2. Implementing Circuit Breaker Pattern
    3. 3. Implementing Retry Pattern
    4. 4. Implementing Timeout Pattern
    5. 5. Implementing Bulkhead Pattern
    6. 6. Implementing Graceful Degradation
    7. 7. Using Failure Detection
    8. 8. Handling Cascading Failures
    9. 9. Implementing Self-Healing
    10. 10. Managing Partial System Availability
    11. 11. Using Redundancy
    12. 12. Using Resilience Libraries

  23. Implementing Error Handling

    1. 1. Defining Error Response Format
    2. Example: Problem Details body
    3. 2. Using HTTP Status Codes
    4. 3. Implementing Error Codes
    5. 4. Adding Error Context
    6. 5. Handling Validation Errors
    7. 6. Implementing Global Error Handlers
    8. Example: Spring Boot 3 @RestControllerAdvice
    9. 7. Logging Errors
    10. 8. Propagating Errors
    11. 9. Implementing Fallback Responses
    12. 10. Handling Timeout Errors
    13. 11. Implementing Retry Logic
    14. 12. Using Error Aggregation

  24. Implementing Caching Strategies

    1. 1. Using Client-Side Caching
    2. 2. Implementing Server-Side Caching
    3. 3. Using Distributed Caching
    4. 4. Implementing Cache-Aside Pattern
    5. 5. Implementing Read-Through Pattern
    6. 6. Implementing Write-Through Pattern
    7. 7. Implementing Write-Behind Pattern
    8. 8. Managing Cache Invalidation
    9. 9. Using Cache Keys
    10. 10. Implementing Cache Warming
    11. 11. Handling Cache Stampede
    12. 12. Implementing HTTP Caching Headers

  25. Implementing Load Balancing

    1. 1. Using Round Robin Algorithm
    2. 2. Using Least Connections Algorithm
    3. 3. Using Weighted Round Robin
    4. 4. Using IP Hash Algorithm
    5. 5. Implementing Health-Based Routing
    6. 6. Implementing Sticky Sessions
    7. 7. Using Geographic Load Balancing
    8. 8. Implementing Layer 7 Load Balancing
    9. 9. Using Layer 4 Load Balancing
    10. 10. Handling Load Balancer Failures
    11. 11. Using Load Balancing Tools
    12. 12. Implementing Dynamic Load Balancing

  26. Implementing API Versioning

    1. 1. Using URI Versioning
    2. 2. Using Header Versioning
    3. 3. Using Query Parameter Versioning
    4. 4. Using Content Negotiation
    5. 5. Implementing Backward Compatibility
    6. 6. Managing Breaking Changes
    7. 7. Deprecating Old Versions
    8. 8. Supporting Multiple Versions
    9. 9. Implementing Version Routing
    10. 10. Documenting Version Changes
    11. 11. Using Semantic Versioning
    12. 12. Implementing API Lifecycle Management

  27. Implementing Distributed Tracing

    1. 1. Understanding Distributed Tracing Concepts
    2. 2. Generating Trace IDs
    3. 3. Propagating Trace Context
    4. 4. Creating Spans
    5. Example: OpenTelemetry (Java)
    6. 5. Using Parent-Child Relationships
    7. 6. Adding Span Tags
    8. 7. Adding Span Logs
    9. 8. Implementing Sampling Strategies
    10. 9. Correlating Traces Across Services
    11. 10. Analyzing Trace Data
    12. 11. Implementing Error Tracing
    13. 12. Using Tracing Tools

  28. Implementing Logging Strategies

    1. 1. Using Structured Logging
    2. Example: JSON log event
    3. 2. Implementing Log Levels
    4. 3. Adding Correlation IDs
    5. 4. Centralizing Logs
    6. 5. Implementing Log Sampling
    7. 6. Using Contextual Logging
    8. 7. Logging Security Events
    9. 8. Handling Sensitive Data
    10. 9. Implementing Log Retention
    11. 10. Using Log Timestamps
    12. 11. Implementing Log Rotation
    13. 12. Using Logging Tools

  29. Implementing Monitoring and Metrics

    1. 1. Collecting Application Metrics
    2. 2. Implementing Health Endpoints
    3. 3. Using RED Metrics
    4. 4. Using USE Metrics
    5. 5. Monitoring Business Metrics
    6. 6. Implementing Custom Metrics
    7. Example: Micrometer (Java)
    8. 7. Using Metric Labels
    9. 8. Setting Up Alerting Rules
    10. Example: Prometheus alert rule
    11. 9. Implementing SLO Monitoring
    12. 10. Creating Dashboards
    13. 11. Implementing Metric Aggregation
    14. 12. Using Monitoring Tools

  30. Implementing Observability Practices

    1. 1. Understanding Observability Pillars
    2. 2. Implementing Distributed Tracing
    3. 3. Collecting Metrics
    4. 4. Centralizing Logs
    5. 5. Creating Dashboards
    6. 6. Setting Up Alerts
    7. 7. Implementing SLO Monitoring
    8. 8. Using Correlation IDs
    9. 9. Implementing Error Tracking
    10. 10. Creating Service Dependency Maps
    11. 11. Implementing Audit Trails
    12. 12. Using OpenTelemetry for Standardization

  31. Implementing Service Testing

    1. 1. Writing Unit Tests
    2. 2. Writing Integration Tests
    3. 3. Implementing Contract Testing
    4. 4. Using Component Testing
    5. 5. Implementing End-to-End Testing
    6. 6. Testing Asynchronous Communication
    7. 7. Implementing Chaos Testing
    8. 8. Testing Security
    9. 9. Implementing Performance Testing
    10. 10. Using Test Doubles
    11. 11. Testing Resilience Patterns
    12. 12. Using Testing Tools

  32. Implementing Performance Optimization

    1. 1. Optimizing Database Queries
    2. 2. Implementing Connection Pooling
    3. 3. Using Asynchronous Processing
    4. 4. Implementing Lazy Loading
    5. 5. Using Batch Processing
    6. 6. Optimizing Payload Size
    7. 7. Implementing Parallel Processing
    8. 8. Using CDN for Static Assets
    9. 9. Optimizing Network Latency
    10. 10. Implementing Query Optimization
    11. 11. Using HTTP/2 and HTTP/3
    12. 12. Implementing Response Compression

  33. Implementing Scalability Patterns

    1. 1. Scaling Horizontally
    2. 2. Scaling Vertically
    3. 3. Implementing Stateless Services
    4. 4. Using Database Sharding
    5. 5. Implementing Read Replicas
    6. 6. Using Event Sourcing
    7. 7. Implementing CQRS
    8. 8. Using Asynchronous Processing
    9. 9. Implementing Auto-Scaling
    10. 10. Managing Hot Partitions
    11. 11. Using Database Connection Pooling
    12. 12. Implementing Queue-Based Load Leveling

  34. Implementing Asynchronous Processing

    1. 1. Using Message Queues
    2. 2. Implementing Background Jobs
    3. 3. Using Event-Driven Processing
    4. 4. Implementing Worker Pools
    5. 5. Managing Long-Running Operations
    6. 6. Using Webhooks
    7. 7. Implementing Polling vs Push Mechanisms
    8. 8. Managing Job Queues
    9. 9. Implementing Status Tracking
    10. 10. Handling Async Failures
    11. 11. Implementing Async Request-Reply
    12. 12. Using Async Processing Tools

  35. Managing Service Deployment

    1. 1. Using Blue-Green Deployment
    2. 2. Implementing Canary Releases
    3. 3. Using Rolling Updates
    4. 4. Implementing Feature Toggles
    5. 5. Using A/B Testing
    6. 6. Implementing Shadow Deployment
    7. 7. Managing Deployment Pipelines
    8. 8. Implementing Rollback Strategies
    9. 9. Using Infrastructure as Code
    10. 10. Implementing Zero-Downtime Deployment
    11. 11. Managing Database Migrations
    12. 12. Using Deployment Tools

  36. Working with Container Orchestration

    1. 1. Understanding Container Orchestration
    2. 2. Defining Service Manifests
    3. Example: Kubernetes Deployment + Service
    4. 3. Managing Service Replicas
    5. 4. Implementing Health Checks
    6. 5. Using Resource Limits
    7. 6. Implementing Service Discovery
    8. 7. Managing Configuration
    9. 8. Handling Secrets
    10. 9. Implementing Rolling Updates
    11. 10. Using Persistent Storage
    12. 11. Implementing Auto-Scaling
    13. 12. Managing Namespaces and Multi-Tenancy

  37. Working with Cloud-Native Technologies

    1. 1. Using Containerization
    2. 2. Implementing Container Orchestration
    3. 3. Using Serverless Functions
    4. 4. Implementing API Gateways
    5. 5. Using Managed Databases
    6. 6. Implementing Message Queues
    7. 7. Using Object Storage
    8. 8. Implementing CDN
    9. 9. Using Cloud Monitoring
    10. 10. Implementing Infrastructure as Code
    11. 11. Using Managed Kubernetes
    12. 12. Implementing Cloud-Native Patterns

  38. Implementing Development Workflows

    1. 1. Setting Up Local Development
    2. 2. Implementing Service Stubs
    3. 3. Using Contract Testing
    4. 4. Implementing Feature Branches
    5. 5. Using Trunk-Based Development
    6. 6. Implementing Code Reviews
    7. 7. Setting Up CI/CD Pipelines
    8. 8. Using Service Templates
    9. 9. Implementing Database Migrations
    10. 10. Managing Shared Libraries
    11. 11. Using Monorepo vs Polyrepo Strategies
    12. 12. Implementing Developer Experience

  39. Managing Service Documentation

    1. 1. Documenting REST APIs
    2. 2. Documenting GraphQL APIs
    3. 3. Documenting gRPC APIs
    4. 4. Creating Architecture Diagrams
    5. 5. Documenting Service Contracts
    6. 6. Maintaining API Changelog
    7. 7. Documenting Configuration
    8. 8. Creating Runbooks
    9. 9. Documenting Error Codes
    10. 10. Maintaining Developer Guides
    11. 11. Using API Documentation Tools
    12. 12. Implementing Interactive Documentation

  40. Implementing Service Governance

    1. 1. Defining Service Standards
    2. 2. Implementing Service Registry
    3. 3. Managing Service Lifecycle
    4. 4. Enforcing API Standards
    5. 5. Implementing Service Ownership
    6. 6. Managing Service Dependencies
    7. 7. Implementing Change Management
    8. 8. Enforcing Security Policies
    9. 9. Managing Service Versioning
    10. 10. Implementing Cost Management
    11. 11. Using Governance Tools
    12. 12. Implementing API Gateway Governance

  41. Handling Cross-Cutting Concerns

    1. 1. Implementing Request Correlation
    2. 2. Managing Service Identity
    3. 3. Implementing Tenant Isolation
    4. 4. Handling Internationalization
    5. 5. Implementing Audit Logging
    6. 6. Managing Data Privacy
    7. 7. Implementing Compliance Controls
    8. 8. Handling Time Zones
    9. 9. Implementing Accessibility
    10. 10. Managing Environmental Configuration
    11. 11. Implementing Feature Flags
    12. 12. Managing Cross-Service Transactions

  42. Migrating to Microservices

    1. 1. Assessing Monolith Architecture
    2. 2. Identifying Service Boundaries
    3. 3. Using Strangler Fig Pattern
    4. 4. Implementing Anti-Corruption Layer
    5. 5. Extracting Services Gradually
    6. 6. Managing Data Migration
    7. 7. Implementing Feature Parity
    8. 8. Testing During Migration
    9. 9. Managing Team Transition
    10. 10. Handling Rollback Scenarios
    11. 11. Using Branch by Abstraction
    12. 12. Implementing Parallel Run Strategy

  43. Implementing Disaster Recovery

    1. 1. Designing Backup Strategies
    2. 2. Implementing Recovery Point Objective
    3. 3. Implementing Recovery Time Objective
    4. 4. Using Multi-Region Deployment
    5. 5. Implementing Failover Mechanisms
    6. 6. Testing Disaster Recovery
    7. 7. Managing Data Replication
    8. 8. Implementing Circuit Breakers
    9. 9. Using Chaos Engineering
    10. 10. Maintaining Disaster Recovery Plans
    11. 11. Implementing Active-Active vs Active-Passive
    12. 12. Using DR Automation Tools

  44. Implementing Cost Optimization

    1. 1. Rightsizing Service Instances
    2. 2. Implementing Auto-Scaling
    3. 3. Using Spot Instances
    4. 4. Implementing Resource Limits
    5. 5. Optimizing Database Usage
    6. 6. Using Caching Effectively
    7. 7. Implementing Data Lifecycle
    8. 8. Monitoring Resource Usage
    9. 9. Implementing Reserved Capacity
    10. 10. Optimizing Network Traffic
    11. 11. Using FinOps Practices
    12. 12. Implementing Cost Allocation Tags