Cloud Design Patterns
GitHubOfficialFirst committed by fatihdurgutDistributed by GitHub
- Skill
- Guidelines
- Software development
- MIT
- No issues found
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
Cloud Design Patterns provides a structured collection of architectural solutions designed to address common challenges in distributed systems. It helps architects and developers navigate the complexities of cloud-native design by offering technology-agnostic patterns that mitigate risks associated with distributed computing, such as network latency, reliability, and security. The collection covers seven key categories including reliability, performance, messaging, architecture, deployment, security, and event-driven design, enabling teams to make informed trade-off decisions when building modern applications.
What it does
- Provides definitions and problem-solution mappings for 42 cloud design patterns.
- Categorizes patterns by architectural focus such as performance, reliability, and security.
- Offers guidance on when to apply specific patterns to solve distributed system challenges.
- Highlights implementation considerations and trade-offs for each architectural pattern.
- Maps common design patterns to relevant cloud service types.
- Addresses common fallacies of distributed computing through architectural mitigation strategies.
When to use it
- When designing the architecture for a new distributed cloud application.
- During architectural reviews to identify potential weaknesses or optimization opportunities.
- When evaluating strategies to improve system reliability, performance, or security.
- When planning the migration or modernization of legacy systems.
- When seeking standard approaches to common cross-cutting concerns like API management or messaging.
Advantages
- Technology-agnostic guidance applicable across various cloud and hybrid environments.
- Focuses on architectural trade-offs rather than specific implementation details.
- Helps prevent common design flaws by addressing distributed system fallacies.
- Provides a standardized vocabulary for architectural discussions within development teams.
Usage examples
- “What pattern should I use to integrate a legacy system with a new microservices architecture?”
- The agent recommends the Anti-Corruption Layer pattern, explaining how to implement a facade to isolate the modern system from legacy constraints.
- “How can I improve the performance of my application when clients need data from multiple backend services?”
- The agent suggests the Gateway Aggregation pattern to combine multiple backend requests into a single call, reducing chattiness and latency.
Install
Download the skill as a ZIP:
https://autogineer.com/agent-skills/github/cloud-design-patterns/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip cloud-design-patterns.zip -d .agents/skills
Documentation by fatihdurgut
Cloud Design Patterns
Architects design workloads by integrating platform services, functionality, and code to meet both functional and nonfunctional requirements. To design effective workloads, you must understand these requirements and select topologies and methodologies that address the challenges of your workload's constraints. Cloud design patterns provide solutions to many common challenges.
System design heavily relies on established design patterns. You can design infrastructure, code, and distributed systems by using a combination of these patterns. These patterns are crucial for building reliable, highly secure, cost-optimized, operationally efficient, and high-performing applications in the cloud.
The following cloud design patterns are technology-agnostic, which makes them suitable for any distributed system. You can apply these patterns across Azure, other cloud platforms, on-premises setups, and hybrid environments.
How Cloud Design Patterns Enhance the Design Process
Cloud workloads are vulnerable to the fallacies of distributed computing, which are common but incorrect assumptions about how distributed systems operate. Examples of these fallacies include:
The network is reliable.
Latency is zero.
Bandwidth is infinite.
The network is secure.
Topology doesn't change.
There's one administrator.
Component versioning is simple.
Observability implementation can be delayed.
These misconceptions can result in flawed workload designs. Design patterns don't eliminate these misconceptions but help raise awareness, provide compensation strategies, and provide mitigations. Each cloud design pattern has trade-offs. Focus on why you should choose a specific pattern instead of how to implement it.
References
| Reference | When to load |
|---|---|
| Reliability & Resilience Patterns | Ambassador, Bulkhead, Circuit Breaker, Compensating Transaction, Retry, Health Endpoint Monitoring, Leader Election, Saga, Sequential Convoy |
| Performance Patterns | Async Request-Reply, Cache-Aside, CQRS, Index Table, Materialized View, Priority Queue, Queue-Based Load Leveling, Rate Limiting, Sharding, Throttling |
| Messaging & Integration Patterns | Choreography, Claim Check, Competing Consumers, Messaging Bridge, Pipes and Filters, Publisher-Subscriber, Scheduler Agent Supervisor |
| Architecture & Design Patterns | Anti-Corruption Layer, Backends for Frontends, Gateway Aggregation/Offloading/Routing, Sidecar, Strangler Fig |
| Deployment & Operational Patterns | Compute Resource Consolidation, Deployment Stamps, External Configuration Store, Geode, Static Content Hosting |
| Security Patterns | Federated Identity, Quarantine, Valet Key |
| Event-Driven Architecture Patterns | Event Sourcing |
| Best Practices & Pattern Selection | Selecting appropriate patterns, Well-Architected Framework alignment, documentation, monitoring |
| Azure Service Mappings | Common Azure services for each pattern category |
Pattern Categories at a Glance
| Category | Patterns | Focus |
|---|---|---|
| Reliability & Resilience | 9 patterns | Fault tolerance, self-healing, graceful degradation |
| Performance | 10 patterns | Caching, scaling, load management, data optimization |
| Messaging & Integration | 7 patterns | Decoupling, event-driven communication, workflow coordination |
| Architecture & Design | 7 patterns | System boundaries, API gateways, migration strategies |
| Deployment & Operational | 5 patterns | Infrastructure management, geo-distribution, configuration |
| Security | 3 patterns | Identity, access control, content validation |
| Event-Driven Architecture | 1 pattern | Event sourcing and audit trails |
External Links
Files
- ATTRIBUTION.mdAdded by AutoGineer881 B
- LICENSELicence file added by AutoGineer1.0 KiB
- SKILL.md4.4 KiB
- references/architecture-design.md4.6 KiB
- references/azure-service-mappings.md606 B
- references/best-practices.md1.6 KiB
- references/deployment-operational.md3.2 KiB
- references/event-driven.md715 B
- references/messaging-integration.md4.5 KiB
- references/performance.md6.6 KiB
- references/reliability-resilience.md6.2 KiB
- references/security.md1.8 KiB
references/security.md
Security Patterns
Federated Identity Pattern
Problem: Applications must manage user authentication and authorization.
Solution: Delegate authentication to an external identity provider.
When to Use:
Implementing single sign-on (SSO)
Reducing authentication complexity
Supporting social identity providers
Implementation Considerations:
Use Azure AD, Auth0, or other identity providers
Implement OAuth 2.0, OpenID Connect, or SAML
Store minimal user data locally
Handle identity provider outages gracefully
Implement proper token validation
Quarantine Pattern
Problem: External assets may contain malicious content or vulnerabilities.
Solution: Ensure that external assets meet a team-agreed quality level before the workload consumes them.
When to Use:
Processing user-uploaded files
Consuming external data or packages
Implementing zero-trust architectures
Implementation Considerations:
Scan all external content before use (malware, vulnerabilities)
Isolate quarantine environment from production
Define clear quality gates for release
Implement automated scanning and validation
Log all quarantine activities for audit
Valet Key Pattern
Problem: Applications shouldn't proxy all client data access.
Solution: Use a token or key that provides clients with restricted direct access to a specific resource or service.
When to Use:
Providing direct access to storage without proxying
Minimizing data transfer through application tier
Implementing time-limited or constrained access
Implementation Considerations:
Generate SAS tokens or pre-signed URLs
Set appropriate expiration times
Limit permissions (read-only, write-only, specific operations)
Implement token revocation if needed
Monitor usage of valet keys
Requirements and compatibility
Written for: GitHub Copilot
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Security
No issues found by our static scan· No issues found
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- First committed by
fatihdurgut
- Publisher
- GitHub (Official)
- Distributed by
- GitHub
- Source
- github/awesome-copilot · skills/cloud-design-patterns · commit 797337f
- Licence
- MIT License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
- Contributors
- fatihdurgut
AutoGineer is not affiliated with or endorsed by fatihdurgut or GitHub.
Related skills
Setup TS Deep Modules
Matt Pocock· Community
Configures dependency-cruiser to enforce deep module boundaries in TypeScript repositories.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITLow riskHas scriptsGitHub stars of the source repository317.5k
To Spec
Matt Pocock· Community
Synthesizes conversation context into a structured technical specification and publishes it to a project issue tracker.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Improve Codebase Architecture
Matt Pocock· Community
A systematic process to identify, visualize, and refine architectural deepening opportunities in a codebase.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Domain Modeling
Matt Pocock· Community
An expert assistant for defining project terminology, maintaining a glossary, and documenting architectural decisions.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Codebase Design
Matt Pocock· Community
A shared vocabulary and set of principles for designing deep, testable, and maintainable software modules.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Prototype
Matt Pocock· Community
Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.
Software developmentClaude CodeClaude appsOpenAI Codex+14 moreMITGitHub stars of the source repository317.5k
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download cloud-design-patterns.zip