48 docs tagged with "best-practices"

Build inclusive software that works for users with disabilities and diverse abilities.

Fix common incidents automatically; guide complex incidents with runbooks.

Design systems that evolve safely without breaking users and manage versions with semantic clarity.

Automate compilation, testing, and security scanning to catch issues before production.

Services making excessive network calls for operations that could be done locally or batched.

Master the discipline of separating configuration from code for flexibility and safety.

Track infrastructure costs, attribute costs to services, and optimize spend.

Separate read and write models to optimize for different access patterns and enable flexible data transformation.

Scale data storage horizontally by distributing data across multiple databases and replicas.

Isolate service data with dedicated databases to maintain independence and prevent tight coupling.

High-level modules should not depend on low-level modules; both should depend on abstractions. Invert the dependency flow.

Services that call each other synchronously in sequence, creating tight coupling and monolith behavior.

Master DRY principle: eliminate knowledge duplication for maintainable code, improved consistency, and reduced bugs.

Design environments that catch problems early without slowing development.

Quantify acceptable unreliability; measure and eliminate manual toil.

Design robust error handling strategies that fail gracefully and guide users to recovery.

Store the complete history of changes as immutable events rather than storing only the current state.

Detect and report errors immediately to prevent silent failures, data corruption, and cascading problems.

Understand the eight false assumptions that undermine distributed systems and learn to design systems that don't depend on them.

Use feature flags to decouple deployment from release and enable safer experimentation.

Scale APIs to handle large datasets with efficient query parameters

Predict growth, measure resource needs, and provision infrastructure to meet demand with margin.

Manage incidents from detection to resolution to learning. Blameless postmortems prevent recurrence.

Protect systems through rigorous input validation and defensive programming practices.

Clients should not depend on interfaces they don't use. Break large interfaces into smaller, focused ones.

Design applications that work for users in any language and cultural context.

Simplicity first: write code that humans understand before optimizing for machines.

Master the Principle of Least Knowledge to reduce coupling and improve maintainability in complex systems.

Use log levels strategically, enforce consistency across teams, and optimize storage costs while maintaining debuggability.

Manage log lifecycle responsibly: comply with regulations, protect sensitive data, and optimize retention periods.

Collect and analyze logs with structure and correlation IDs to understand system behavior.

Measure system behavior with metrics using RED and USE methods to identify performance issues.

Master naming conventions that clarify code intent and improve readability across all programming contexts.

Services too small to be useful, requiring many inter-service calls and creating excessive complexity.

Software entities should be open for extension, closed for modification. Design for change without breaking existing code.

Ensure reliable event publishing and delivery with outbox, inbox, and CDC patterns.

Every inter-service communication is synchronous, creating blocking dependencies and reducing resilience.

Design systems where behavior matches user expectations, minimizing surprise and confusion.

Control flow of changes through environments; approve releases with appropriate rigor.

Guide incident response with runbooks; structure on-call rotations for coverage and sustainability.

Evolve data schemas safely without breaking clients as systems change over time.

Manage credentials, API keys, and configuration safely; never commit secrets to version control.

Multiple services accessing the same database directly, creating coupling and preventing independence.

Alert on service-level objectives, not arbitrary thresholds. Align alerts with actual user impact.

Log structured data to enable queries, use correlation IDs to track requests, and maintain context across async boundaries.

Coordinate distributed transactions across services using choreography and orchestration patterns.

Master REST fundamentals: clear URIs, appropriate methods, and meaningful status codes

Push events to external systems reliably with webhooks