├── CNAME ├── .gitignore ├── contact-us.md ├── assets ├── images │ ├── cs.png │ ├── book.png │ ├── cards.png │ ├── cicd.png │ ├── saas.png │ ├── Asset 43.png │ ├── Asset 44.png │ ├── Asset 45.png │ ├── Asset 47.png │ ├── SRE team.png │ ├── big bet.png │ ├── gitops.png │ ├── metrics.png │ ├── runbooks.png │ ├── workshop.png │ ├── Serverless.png │ ├── core team.png │ ├── Learning loop.png │ ├── Observability.png │ ├── Self service.png │ ├── a-b testing.png │ ├── book_mockup.png │ ├── business case.png │ ├── platform team.png │ ├── private cloud.png │ ├── public cloud .png │ ├── remote teams.png │ ├── vision first.png │ ├── (platform) MVP.png │ ├── Honest feedback.png │ ├── No regret move.png │ ├── build-run teams.png │ ├── dynamic_secrets.png │ ├── pattern black_1.png │ ├── pattern white_1.png │ ├── value hierarchy.png │ ├── Demo applications.png │ ├── Dynamic strategy.png │ ├── Objective setting.png │ ├── Options _ Hedges.png │ ├── Strangle monolith.png │ ├── automated testing.png │ ├── blameless inquiry.png │ ├── co-located teams.png │ ├── containerized apps.png │ ├── delayed automation.png │ ├── dynamic scheduling.png │ ├── gradual onboarding.png │ ├── network issolation.png │ ├── ongoing education.png │ ├── pattern_background.png │ ├── periodic check-ups.png │ ├── proof of concept.png │ ├── service_priority.png │ ├── Internal evangelism_.png │ ├── Operations-patterns.png │ ├── Psychological safety.png │ ├── Webp.net-resizeimage.png │ ├── continuous delivery.png │ ├── distributed systems.png │ ├── executive commitment.png │ ├── measure what matters.png │ ├── Communicate through API.png │ ├── DEVELOPER STARTER PACK.png │ ├── Learning organization.png │ ├── No long tests in CI-CD.png │ ├── Reference architecture.png │ ├── Transformation champion.png │ ├── continuous deployment.png │ ├── continuous integration.png │ ├── ephemeral_environments.png │ ├── manage for creativity.png │ ├── manage for proficiency.png │ ├── research through action.png │ ├── Decide closest to action.png │ ├── Full production readiness.png │ ├── Personalised Co-creation.png │ ├── Risk reducing deployments.png │ ├── agile for new development.png │ ├── automated infrastructure.png │ ├── exit strategy over vendor.png │ ├── lift and shift at the end.png │ ├── Reproducible dev environment.png │ ├── avoid reinventing the wheel.png │ ├── communicating through tribes.png │ ├── data-driven decision making.png │ ├── microservices architecture.png │ ├── Gradually raising the stakes .png │ ├── Open source internal projects.png │ ├── Screenshot 2020-01-06 at 14.07.47.png │ ├── Strangle monolithic organisation.png │ └── design thinking for (R) innovation.png └── css │ └── style.scss ├── _sass └── components │ ├── _logo.scss │ ├── _page.scss │ ├── _header.scss │ ├── _forms.scss │ ├── _title.scss │ ├── _main-menu.scss │ ├── _buttons.scss │ ├── _footer.scss │ ├── _content.scss │ └── _patterns.scss ├── LICENSE ├── _includes ├── analytics.html ├── form.html ├── scripts.html ├── footer.html ├── links.html ├── title.html └── header.html ├── operations.md ├── _config.yml ├── infrastructure-cloud.md ├── development-design.md ├── organization-culture.md ├── _layouts ├── default.html ├── homepage.html └── pattern.html ├── strategy-risk-reduction.md ├── README.md ├── cta-section.md ├── index.md ├── book-section.md ├── _operations ├── runbooks.md ├── service-priority.md ├── gitops.md ├── network-isolation.md ├── customization-through-microservices.md ├── metrics-over-logs.md ├── cicd-as-platform.md ├── ephemeral-environments.md └── dynamic-secrets.md ├── _organization-culture ├── co-located-teams.md ├── agile-for-new-development.md ├── lean-for-optimization.md ├── communicate-through-tribes.md ├── design-thinking-for-radical-innovation.md ├── gradual-onboarding.md ├── blameless-inquiry.md ├── ongoing-education.md ├── exploratory-experiments.md ├── proof-of-concept-poc.md ├── sre-team.md ├── productive-feedback.md ├── personalized-relationships-for-co-creation.md ├── decide-closest-to-the-action.md ├── mvp-platform.md ├── core-team.md └── platform-team.md ├── _development-design ├── delayed-automation.md ├── developer-starter-pack.md ├── continuous-integration.md ├── communicate-through-apis.md ├── automated-testing.md ├── microservices-architecture.md ├── distributed-systems.md ├── no-long-tests-in-ci-cd.md ├── open-source-internal-projects.md ├── a-b-testing.md ├── reproducible-dev-environments.md ├── demo-applications.md └── avoid-reinventing-the-wheel.md ├── _strategy-risk-reduction ├── periodic-checkups.md ├── value-hierarchy.md ├── vision-first.md ├── measure-what-matters.md ├── executive-commitment.md ├── data-driven-decision-making.md ├── options-and-hedges.md ├── reduce-cost-of-experimentation.md ├── research-through-action.md ├── big-bet.md ├── learning-organization.md ├── learning-loop.md ├── exit-strategy-over-vendor-lock-in.md ├── business-case.md └── dynamic-strategy.md ├── patterns-library.md ├── _infrastructure-cloud ├── containerized-apps.md ├── public-cloud.md ├── full-production-readiness.md ├── self-service.md ├── automated-infrastructure.md ├── continuous-delivery.md ├── observability.md ├── continuous-deployment.md └── private-cloud.md └── CONTRIBUTING.md /CNAME: -------------------------------------------------------------------------------- 1 | www.cnpatterns.org -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .jekyll-cache/ 2 | _site/ 3 | .jekyll-metadata 4 | -------------------------------------------------------------------------------- /contact-us.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Contact Us 3 | layout: default 4 | --- 5 | 6 | {% include form.html %} 7 | -------------------------------------------------------------------------------- /assets/images/cs.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/cs.png -------------------------------------------------------------------------------- /assets/images/book.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/book.png -------------------------------------------------------------------------------- /assets/images/cards.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/cards.png -------------------------------------------------------------------------------- /assets/images/cicd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/cicd.png -------------------------------------------------------------------------------- /assets/images/saas.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/saas.png -------------------------------------------------------------------------------- /assets/images/Asset 43.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Asset 43.png -------------------------------------------------------------------------------- /assets/images/Asset 44.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Asset 44.png -------------------------------------------------------------------------------- /assets/images/Asset 45.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Asset 45.png -------------------------------------------------------------------------------- /assets/images/Asset 47.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Asset 47.png -------------------------------------------------------------------------------- /assets/images/SRE team.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/SRE team.png -------------------------------------------------------------------------------- /assets/images/big bet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/big bet.png -------------------------------------------------------------------------------- /assets/images/gitops.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/gitops.png -------------------------------------------------------------------------------- /assets/images/metrics.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/metrics.png -------------------------------------------------------------------------------- /assets/images/runbooks.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/runbooks.png -------------------------------------------------------------------------------- /assets/images/workshop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/workshop.png -------------------------------------------------------------------------------- /assets/images/Serverless.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Serverless.png -------------------------------------------------------------------------------- /assets/images/core team.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/core team.png -------------------------------------------------------------------------------- /assets/images/Learning loop.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Learning loop.png -------------------------------------------------------------------------------- /assets/images/Observability.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Observability.png -------------------------------------------------------------------------------- /assets/images/Self service.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Self service.png -------------------------------------------------------------------------------- /assets/images/a-b testing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/a-b testing.png -------------------------------------------------------------------------------- /assets/images/book_mockup.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/book_mockup.png -------------------------------------------------------------------------------- /assets/images/business case.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/business case.png -------------------------------------------------------------------------------- /assets/images/platform team.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/platform team.png -------------------------------------------------------------------------------- /assets/images/private cloud.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/private cloud.png -------------------------------------------------------------------------------- /assets/images/public cloud .png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/public cloud .png -------------------------------------------------------------------------------- /assets/images/remote teams.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/remote teams.png -------------------------------------------------------------------------------- /assets/images/vision first.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/vision first.png -------------------------------------------------------------------------------- /assets/images/(platform) MVP.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/(platform) MVP.png -------------------------------------------------------------------------------- /assets/images/Honest feedback.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Honest feedback.png -------------------------------------------------------------------------------- /assets/images/No regret move.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/No regret move.png -------------------------------------------------------------------------------- /assets/images/build-run teams.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/build-run teams.png -------------------------------------------------------------------------------- /assets/images/dynamic_secrets.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/dynamic_secrets.png -------------------------------------------------------------------------------- /assets/images/pattern black_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/pattern black_1.png -------------------------------------------------------------------------------- /assets/images/pattern white_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/pattern white_1.png -------------------------------------------------------------------------------- /assets/images/value hierarchy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/value hierarchy.png -------------------------------------------------------------------------------- /_sass/components/_logo.scss: -------------------------------------------------------------------------------- 1 | .logo { 2 | font-size: 20px; 3 | 4 | a { 5 | color: inherit; 6 | text-decoration: none; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /assets/images/Demo applications.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Demo applications.png -------------------------------------------------------------------------------- /assets/images/Dynamic strategy.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Dynamic strategy.png -------------------------------------------------------------------------------- /assets/images/Objective setting.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Objective setting.png -------------------------------------------------------------------------------- /assets/images/Options _ Hedges.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Options _ Hedges.png -------------------------------------------------------------------------------- /assets/images/Strangle monolith.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Strangle monolith.png -------------------------------------------------------------------------------- /assets/images/automated testing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/automated testing.png -------------------------------------------------------------------------------- /assets/images/blameless inquiry.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/blameless inquiry.png -------------------------------------------------------------------------------- /assets/images/co-located teams.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/co-located teams.png -------------------------------------------------------------------------------- /assets/images/containerized apps.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/containerized apps.png -------------------------------------------------------------------------------- /assets/images/delayed automation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/delayed automation.png -------------------------------------------------------------------------------- /assets/images/dynamic scheduling.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/dynamic scheduling.png -------------------------------------------------------------------------------- /assets/images/gradual onboarding.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/gradual onboarding.png -------------------------------------------------------------------------------- /assets/images/network issolation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/network issolation.png -------------------------------------------------------------------------------- /assets/images/ongoing education.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/ongoing education.png -------------------------------------------------------------------------------- /assets/images/pattern_background.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/pattern_background.png -------------------------------------------------------------------------------- /assets/images/periodic check-ups.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/periodic check-ups.png -------------------------------------------------------------------------------- /assets/images/proof of concept.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/proof of concept.png -------------------------------------------------------------------------------- /assets/images/service_priority.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/service_priority.png -------------------------------------------------------------------------------- /assets/images/Internal evangelism_.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Internal evangelism_.png -------------------------------------------------------------------------------- /assets/images/Operations-patterns.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Operations-patterns.png -------------------------------------------------------------------------------- /assets/images/Psychological safety.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Psychological safety.png -------------------------------------------------------------------------------- /assets/images/Webp.net-resizeimage.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Webp.net-resizeimage.png -------------------------------------------------------------------------------- /assets/images/continuous delivery.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/continuous delivery.png -------------------------------------------------------------------------------- /assets/images/distributed systems.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/distributed systems.png -------------------------------------------------------------------------------- /assets/images/executive commitment.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/executive commitment.png -------------------------------------------------------------------------------- /assets/images/measure what matters.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/measure what matters.png -------------------------------------------------------------------------------- /assets/images/Communicate through API.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Communicate through API.png -------------------------------------------------------------------------------- /assets/images/DEVELOPER STARTER PACK.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/DEVELOPER STARTER PACK.png -------------------------------------------------------------------------------- /assets/images/Learning organization.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Learning organization.png -------------------------------------------------------------------------------- /assets/images/No long tests in CI-CD.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/No long tests in CI-CD.png -------------------------------------------------------------------------------- /assets/images/Reference architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Reference architecture.png -------------------------------------------------------------------------------- /assets/images/Transformation champion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Transformation champion.png -------------------------------------------------------------------------------- /assets/images/continuous deployment.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/continuous deployment.png -------------------------------------------------------------------------------- /assets/images/continuous integration.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/continuous integration.png -------------------------------------------------------------------------------- /assets/images/ephemeral_environments.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/ephemeral_environments.png -------------------------------------------------------------------------------- /assets/images/manage for creativity.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/manage for creativity.png -------------------------------------------------------------------------------- /assets/images/manage for proficiency.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/manage for proficiency.png -------------------------------------------------------------------------------- /assets/images/research through action.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/research through action.png -------------------------------------------------------------------------------- /assets/images/Decide closest to action.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Decide closest to action.png -------------------------------------------------------------------------------- /assets/images/Full production readiness.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Full production readiness.png -------------------------------------------------------------------------------- /assets/images/Personalised Co-creation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Personalised Co-creation.png -------------------------------------------------------------------------------- /assets/images/Risk reducing deployments.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Risk reducing deployments.png -------------------------------------------------------------------------------- /assets/images/agile for new development.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/agile for new development.png -------------------------------------------------------------------------------- /assets/images/automated infrastructure.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/automated infrastructure.png -------------------------------------------------------------------------------- /assets/images/exit strategy over vendor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/exit strategy over vendor.png -------------------------------------------------------------------------------- /assets/images/lift and shift at the end.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/lift and shift at the end.png -------------------------------------------------------------------------------- /assets/images/Reproducible dev environment.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Reproducible dev environment.png -------------------------------------------------------------------------------- /assets/images/avoid reinventing the wheel.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/avoid reinventing the wheel.png -------------------------------------------------------------------------------- /assets/images/communicating through tribes.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/communicating through tribes.png -------------------------------------------------------------------------------- /assets/images/data-driven decision making.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/data-driven decision making.png -------------------------------------------------------------------------------- /assets/images/microservices architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/microservices architecture.png -------------------------------------------------------------------------------- /assets/images/Gradually raising the stakes .png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Gradually raising the stakes .png -------------------------------------------------------------------------------- /assets/images/Open source internal projects.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Open source internal projects.png -------------------------------------------------------------------------------- /assets/images/Screenshot 2020-01-06 at 14.07.47.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Screenshot 2020-01-06 at 14.07.47.png -------------------------------------------------------------------------------- /assets/images/Strangle monolithic organisation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/Strangle monolithic organisation.png -------------------------------------------------------------------------------- /assets/images/design thinking for (R) innovation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ContainerSolutions/cloud-native-patterns/HEAD/assets/images/design thinking for (R) innovation.png -------------------------------------------------------------------------------- /_sass/components/_page.scss: -------------------------------------------------------------------------------- 1 | .page { 2 | background-color: #fff; 3 | color: #333; 4 | font-family: Dosis, sans-serif; 5 | font-size: 14px; 6 | line-height: 20px; 7 | margin: 0; 8 | min-height: 100%; 9 | } 10 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | cloud-native-patterns (c) by Container Solutions 2 | 3 | cloud-native-patterns is licensed under a 4 | Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. 5 | 6 | You should have received a copy of the license along with this 7 | work. If not, see . 8 | -------------------------------------------------------------------------------- /_includes/analytics.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 9 | -------------------------------------------------------------------------------- /_sass/components/_header.scss: -------------------------------------------------------------------------------- 1 | .header-strip { 2 | background-color: #fff; 3 | color: #000; 4 | font-weight: 800; 5 | position: sticky; 6 | top: 0px; 7 | width: 100%; 8 | z-index: 9999999; 9 | } 10 | 11 | .header { 12 | margin-left: auto; 13 | margin-right: auto; 14 | max-width: 940px; 15 | padding-top: 20px; 16 | padding-bottom: 20px; 17 | } 18 | -------------------------------------------------------------------------------- /_sass/components/_forms.scss: -------------------------------------------------------------------------------- 1 | form { 2 | label { 3 | display: block; 4 | font-size: 20px; 5 | font-weight: 600; 6 | line-height: 30px; 7 | } 8 | 9 | input[type=text], 10 | input[type=email] { 11 | display: block; 12 | font-size: 14px; 13 | height: 30px; 14 | margin: 0px 0px 10px; 15 | padding: 8px 12px; 16 | width: 100%; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /_includes/form.html: -------------------------------------------------------------------------------- 1 |
2 | -------------------------------------------------------------------------------- /assets/css/style.scss: -------------------------------------------------------------------------------- 1 | --- 2 | # this ensures Jekyll reads the file to be transformed into CSS later 3 | --- 4 | 5 | $baseurl: "{{ site.baseurl }}"; 6 | 7 | @import 'components/buttons'; 8 | @import 'components/content'; 9 | @import 'components/footer'; 10 | @import 'components/forms'; 11 | @import 'components/header'; 12 | @import 'components/logo'; 13 | @import 'components/main-menu'; 14 | @import 'components/page'; 15 | @import 'components/patterns'; 16 | @import 'components/title'; 17 | -------------------------------------------------------------------------------- /operations.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Operations 3 | description: "Patterns that focus on the technical and architectural aspects of how to build and operate Cloud Native services whilst ensuring their reliability and security." 4 | layout: default 5 | --- 6 | 7 | 8 | {% tablerow pattern in site.operations cols:2 %} 9 | 10 | {{ pattern.title }} 11 | {% endtablerow %} 12 |
13 | -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | --- 2 | name: Cloud Native Transformation Patterns 3 | title: Cloud Native Transformation Patterns 4 | 5 | kramdown: 6 | parse_block_html: true 7 | permalink: /:title 8 | 9 | collections: 10 | development-design: 11 | output: true 12 | infrastructure-cloud: 13 | output: true 14 | organization-culture: 15 | output: true 16 | strategy-risk-reduction: 17 | output: true 18 | operations: 19 | output: true 20 | 21 | # Google Analytics 22 | google_analytics: UA-53586058-2 23 | -------------------------------------------------------------------------------- /infrastructure-cloud.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Infrastructure & Cloud Patterns 3 | description: Patterns that help in discovering and choosing the right infrastructure, while avoiding common pitfalls like vendor lock-in and building unnecessary custom solutions. 4 | layout: default 5 | --- 6 | 7 | 8 | {% tablerow pattern in site.infrastructure-cloud cols:2 %} 9 | 10 | {{ pattern.title }} 11 | {% endtablerow %} 12 |
13 | -------------------------------------------------------------------------------- /development-design.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Development & Design Patterns 3 | description: "Patterns for how to design, build, and deliver products/services in this new paradigm: architecture and processes that support Cloud Native’s fast and responsive delivery dynamic." 4 | layout: default 5 | --- 6 | 7 | 8 | {% tablerow pattern in site.development-design cols:2 %} 9 | 10 | {{ pattern.title }} 11 | {% endtablerow %} 12 |
13 | -------------------------------------------------------------------------------- /organization-culture.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Organization & Culture Patterns 3 | description: "Patterns to guide organizational evolution: cut down dependencies and empower teams to be independent, proactive, and self-sufficient while delivering rapidly and iteratively." 4 | layout: default 5 | --- 6 | 7 | 8 | {% tablerow pattern in site.organization-culture cols:2 %} 9 | 10 | {{ pattern.title }} 11 | {% endtablerow %} 12 |
13 | -------------------------------------------------------------------------------- /_includes/scripts.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /_layouts/default.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | {% if page.title %}{{ page.title }}{% else %}{{ site.title | escape }}{% endif %} 7 | {% include links.html %} 8 | 9 | 10 | {% include header.html %} 11 | {% include title.html %} 12 |
13 | {{ content }} 14 |
15 | {% include footer.html %} 16 | {% include scripts.html %} 17 | {% include analytics.html %} 18 | 19 | 20 | -------------------------------------------------------------------------------- /_sass/components/_title.scss: -------------------------------------------------------------------------------- 1 | .title-strip { 2 | background-color: #fff; 3 | background-image: url("#{$baseurl}/assets/images/pattern%20black_1.png"); 4 | background-size: cover; 5 | color: #000; 6 | font-size: 25px; 7 | font-weight: 500; 8 | line-height: 30px; 9 | padding: 195px 0px; 10 | } 11 | 12 | .title { 13 | align-items: center; 14 | justify-content: space-between; 15 | max-width: 940px; 16 | margin-left: auto; 17 | margin-right: auto; 18 | 19 | h1 { 20 | font-size: 60px; 21 | font-weight: bold; 22 | line-height: 58px; 23 | text-transform: uppercase; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /strategy-risk-reduction.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Strategy & Risk Reduction Patterns 3 | description: "Patterns that specifically shape and drive overall strategy in a Cloud Native organization: reducing risk and building for long-term success, both during a transformation and then into whatever comes next." 4 | layout: default 5 | --- 6 | 7 | 8 | {% tablerow pattern in site.strategy-risk-reduction cols:2 %} 9 | 10 | {{ pattern.title }} 11 | {% endtablerow %} 12 |
13 | -------------------------------------------------------------------------------- /_includes/footer.html: -------------------------------------------------------------------------------- 1 | 18 | -------------------------------------------------------------------------------- /_sass/components/_main-menu.scss: -------------------------------------------------------------------------------- 1 | .main-menu { 2 | justify-content: flex-end; 3 | 4 | a { 5 | color: inherit; 6 | margin: 10px 20px; 7 | text-decoration: none; 8 | } 9 | 10 | button { 11 | background-color: inherit; 12 | border: none; 13 | color: inherit; 14 | margin: 0 20px 0 0; 15 | } 16 | } 17 | 18 | .dropdown-menu { 19 | background-color: #fff; 20 | color: #000; 21 | } 22 | 23 | .dropdown-item { 24 | font-size: 14px; 25 | font-weight: 800; 26 | padding: 10px 20px; 27 | width: auto; 28 | 29 | &:hover { 30 | background-color: inherit; 31 | color: inherit; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /_sass/components/_buttons.scss: -------------------------------------------------------------------------------- 1 | .button { 2 | background-color: #000; 3 | border: 0; 4 | border-radius: 0; 5 | display: inline-block; 6 | height: 30px; 7 | line-height: inherit; 8 | margin-left: 5px; 9 | margin-right: 15px; 10 | padding: 0px; 11 | white-space: nowrap; 12 | width: 30px; 13 | } 14 | 15 | .button-text, 16 | input[type=submit] { 17 | background-color: #000; 18 | border: 0; 19 | border-radius: 20px; 20 | box-shadow: 0; 21 | color: #fff !important; 22 | display: inline-block; 23 | font-size: 20px; 24 | line-height: 30px; 25 | margin: 10px 0px; 26 | padding: 10px 30px; 27 | 28 | &:hover { 29 | color: #fff; 30 | text-decoration: none; 31 | } 32 | } 33 | 34 | -------------------------------------------------------------------------------- /_includes/links.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /_includes/title.html: -------------------------------------------------------------------------------- 1 |
2 |
3 | {% unless page.url contains '/strategy-risk-reduction' %}{% endunless %} 4 | {% unless page.url contains '/organization-culture' %}{% endunless %} 5 | {% unless page.url contains '/development-design' %}{% endunless %} 6 | {% unless page.url contains '/infrastructure-cloud' %}{% endunless %} 7 | {% unless page.url contains '/operations' %}{% endunless %} 8 |

{{ page.title }}

9 | {{ page.description }} 10 |
11 |
12 | 13 | -------------------------------------------------------------------------------- /_layouts/homepage.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | {% if page.title %}{{ page.title }}{% else %}{{ site.title | escape }}{% endif %} 7 | {% include links.html %} 8 | 9 | 10 | {% include header.html %} 11 | {% include title.html %} 12 |
13 | {{ content }} 14 |
15 |
16 |
17 | {% capture book-section %}{% include_relative book-section.md %}{% endcapture %} 18 | {{ book-section | markdownify }} 19 |
20 |
21 |
22 | {% capture cta-section %}{% include_relative cta-section.md %}{% endcapture %} 23 | {{ cta-section | markdownify }} 24 |
25 | {% include footer.html %} 26 | {% include scripts.html %} 27 | {% include analytics.html %} 28 | 29 | 30 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Cloud Native Transformation Patterns 2 | This site contains patterns for making your organisation Cloud Native. The official URL of the site is [https://cnpatterns.org](https://cnpatterns.org) 3 | 4 | # What are Cloud Native Patterns? 5 | When it comes to Cloud Native, most of us are junior. The technology is so new, and our understanding of the architecture is constantly evolving. Sharing our rapidly growing knowledge is essential. Creating Cloud Native-specific patterns is a way to name the things we are learning as developers, engineers, and technology managers so we can talk to each other more effectively. As we learn and continue, the patterns will evolve and improve alongside our understanding. 6 | 7 | # Contributing 8 | This is far from an exhaustive list of patterns, and we welcome contributions from all industry practicioners who would like 9 | to share their expertise with the community in the form of patterns. 10 | Reach out to us [here](https://cnpatterns.org/contact-us) for help with writing your own patterns. 11 | 12 | # License 13 | See [LICENSE](LICENSE). 14 | -------------------------------------------------------------------------------- /_sass/components/_footer.scss: -------------------------------------------------------------------------------- 1 | .footer-strip { 2 | background-color: #000; 3 | background-image: url("#{$baseurl}/assets/images/pattern_background.png"); 4 | background-size: cover; 5 | color: #fff; 6 | font-weight: 700; 7 | font-size: 15px; 8 | } 9 | 10 | .footer-menu { 11 | align-items: center; 12 | display: block; 13 | flex-direction: row; 14 | justify-content: space-between; 15 | margin-left: auto; 16 | margin-right: auto; 17 | max-width: 940px; 18 | 19 | ul { 20 | list-style: none; 21 | margin: 0; 22 | padding: 0; 23 | text-align: center; 24 | 25 | li { 26 | display: inline-block; 27 | padding: 20px; 28 | 29 | a { 30 | color: #ffffff; 31 | text-decoration: none; 32 | } 33 | } 34 | } 35 | } 36 | 37 | .footer-title { 38 | align-items: center; 39 | display: block; 40 | flex-direction: row; 41 | justify-content: space-between; 42 | margin-left: auto; 43 | margin-right: auto; 44 | max-width: 940px; 45 | text-align: right; 46 | 47 | img { 48 | width: 130px; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /cta-section.md: -------------------------------------------------------------------------------- 1 | --- 2 | --- 3 | 4 |
5 | 6 |
7 | ![Read the book]({{ site.baseurl }}/assets/images/book.png){:height="110px" width="120px"} 8 | 9 | **Read the book** 10 | 11 | Going Cloud Native can be a big advantage, but it’s tough to get right. This practical approach to transformation offers patterns to guide your initiative, whether moving from legacy architectures or creating new systems from scratch. 12 | 13 | {:.mt-auto} 14 | [Get the book](http://shop.oreilly.com/product/0636920235248.do){:.button-text} 15 |
16 | 17 |
18 | ![Take a workshop]({{ site.baseurl }}/assets/images/workshop.png){:height="110px" width="120px"} 19 | 20 | **Take a workshop** 21 | 22 | Groups can jump-start their knowledge of Cloud Native with a half-day workshop. Facilitators lead hands-on exploration of CN concepts, using patterns cards to create a high-level roadmap for a successful transformation. 23 | 24 | {:.mt-auto} 25 | [Workshop info](https://info.container-solutions.com/training/cn-transformation-patterns-workshop){:.button-text} 26 |
27 | 28 |
29 | -------------------------------------------------------------------------------- /index.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Cloud Native Transformation Patterns 3 | description: Tools for creating effective Cloud Native architecture—and remaking the way we work 4 | layout: homepage 5 | --- 6 | 7 | # What are Cloud Native Patterns? 8 | 9 | When it comes to Cloud Native, most of us are junior. The technology is so new, and our understanding of the architecture is constantly evolving. Sharing our rapidly growing knowledge is essential. Creating Cloud Native-specific patterns is a way to name the things we are learning as developers, engineers, and technology managers so we can talk to each other more effectively. As we learn and continue, the patterns will evolve and improve alongside our understanding. 10 | 11 | Patterns are not a hack. They are not a quick and easy way to solve difficult problems without careful thought. Instead, they are a language for sharing context-specific working solutions. And here is the place to find and explore Cloud Native patterns--and, soon, share some of your own. **This site is intended to be the home of a Cloud Native patterns community, the place to explore existing patterns and collaborate on creating new ones.** We openly welcome questions, conversation, and contributions! 12 | 13 | [Explore patterns]({{ site.baseurl }}/patterns-library){:.button-text} 14 | -------------------------------------------------------------------------------- /_layouts/pattern.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | {% if page.title %}{{ page.title }}{% else %}{{ site.title | escape }}{% endif %} 7 | {% include links.html %} 8 | 9 | 10 | {% include header.html %} 11 |
12 | {% if page.url contains '/strategy-risk-reduction' %}Return{% endif %} 13 | {% if page.url contains '/organization-culture' %}Return{% endif %} 14 | {% if page.url contains '/development-design' %}Return{% endif %} 15 | {% if page.url contains '/infrastructure-cloud' %}Return{% endif %} 16 | {% if page.url contains '/operations' %}Return{% endif %} 17 |

Pattern: {{ page.title }}

18 | {{ page.description }} 19 | {{ content }} 20 |
21 | {% include footer.html %} 22 | {% include scripts.html %} 23 | {% include analytics.html %} 24 | 25 | 26 | -------------------------------------------------------------------------------- /book-section.md: -------------------------------------------------------------------------------- 1 | --- 2 | --- 3 | 4 |
5 | 6 |
7 | ![Cloud Native Transformation: Practical Patterns for Innovation]({{ site.baseurl }}/assets/images/book_mockup.png){:height="455px" width="400px"} 8 |
9 | 10 |
11 | # Cloud Native Transformation: Practical Patterns for Innovation 12 | 13 | This website grew from this newly published book from O’Reilly: 78 Cloud Native patterns covering everything from Microservices Architecture to CN DevOps to becoming a responsive Learning Organization that can innovate to adjust to any kind of future. Books are so final, though, and so we sponsored this website to provide a living, evolving patterns repository that grows along with our knowledge and understanding. 14 | 15 | Here you will find not just the newest patterns as they continue to emerge, but also an online community for discussing, creating and improving them. We are inviting people from across the industry, thought leaders and influencers but most importantly everyday engineers and managers—those out there working elbows-deep in Cloud Native code and architecture—to contribute and participate. 16 | 17 | Let’s write more patterns - together! 18 | 19 | You can preview the book by downloading a free 75-page excerpt [here](https://info.container-solutions.com/free-oreilly-cloud-native-transformation-excerpt) 20 |
21 | 22 |
23 | -------------------------------------------------------------------------------- /_operations/runbooks.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Runbooks 3 | description: Use runbooks to proivide a set of instructions, documents, which help to identify quickly the root cause for incidents. 4 | layout: pattern 5 | --- 6 | 7 | ![Runbooks]({{ site.baseurl }}/assets/images/runbooks.png) 8 | 9 | In case of an incident, an effective runbook allows to effectively manage and troubleshoot a system by providing a context for the engineer on duty. 10 | 11 | ## In This Context: 12 | When an alarm is triggered by breaching a defined threshold or condition a runbook links to information or standard procedures for handling an incident. 13 | For this teams have created a useful runbook that is actively maintained and integrated into the alerting infrastructure for easy reference. 14 | 15 | ## Therefore: 16 | By using your post-mortems as a record of what actions and activities have worked, you can then leverage the recorded actions (that fixed the problem) to build your runbooks. 17 | The good runbook at a minimum should include answers for following questions: 18 | 19 | **WHAT:** Triggered the alarm (which tools and which threshold)\ 20 | **HOW:** To start to remediate the problem (i.e. scale-up, roll-back, etc.)\ 21 | **WHO:** Who is the product team which needs to be contacted in case of escalation.\ 22 | **WHERE:** Where can the on-call engineer find information like: documentation, update statuses, etc. 23 | ## Consequently 24 | 25 | {:.plusminus} 26 | - {:.plus} It reduces or eliminates the time it takes for your team to “dig” for your runbooks in a file repository or a wiki link. 27 | - {:.plus} It also reduces the stress accompanied with solving a complex problem at midnight. 28 | - {:.minus} It requires discipline to create them 29 | - {:.minus} The creation is hard to automate 30 | -------------------------------------------------------------------------------- /_includes/header.html: -------------------------------------------------------------------------------- 1 |
2 | 28 | {% if site.google_analytics and jekyll.environment == 'production' %} 29 | {% include analytics.html %} 30 | {% endif %} 31 |
32 | -------------------------------------------------------------------------------- /_organization-culture/co-located-teams.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Co-Located Teams 3 | description: Teams that work together in person develop naturally closer relationships and better collaborative problem-solving abilities, which in turn nurtures greater innovation 4 | layout: pattern 5 | --- 6 | 7 | ![Co-Located Teams]({{ site.baseurl }}/assets/images/co-located%20teams.png) 8 | 9 | An organization that is moving to cloud native has multiple offices and office buildings.Teams that are targeted to move to cloud native have individual members located in multiple physical locations. 10 | 11 | ## In This Context 12 | 13 | When team members are located in different places, they tend to communicate less and focus on their jobs rather than personal relationships. This hobbles team problem-solving, because individuals will attempt to solve problems separately and then contribute that solution back to the team—rather than solving them collaboratively with teammates. 14 | 15 | - Creative teams especially are more effective when personal relationships are on a higher level. 16 | - Complex communication is better in person. 17 | - Cloud native is a paradigm shift that requires new ways of working and creative problem-solving. 18 | 19 | ## Therefore 20 | 21 | All members of a given dev team will work in the same physical location and meetdaily.All meetings and collaboration will be first done using whiteboards, pen and paper,etc. Teams will be chosen based on location. If the team is in the same office, then move the members to sit at adjacent desks. 22 | 23 | - Periodic team-building events to strengthen personal relationships. 24 | - Encourage the team to talk to one another in person. 25 | - Consider pair programming. 26 | 27 | ## Consequently 28 | 29 | High level of trust and proximity naturally increases collaboration. 30 | 31 | {:.plusminus} 32 | - {:.plus} Quick and effective communication. 33 | - {:.minus} Not always possible due to distribution of teams. 34 | - {:.minus} Possibility of personal conflict exists. 35 | -------------------------------------------------------------------------------- /_development-design/delayed-automation.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Delayed Automation 3 | description: Automate processes only after a problem has been completely solved and the solution has been run manually a few times 4 | layout: pattern 5 | --- 6 | 7 | ![Delayed Automation]({{ site.baseurl }}/assets/images/delayed%20automation.png) 8 | 9 | The team is building a complex system that needs to support stress and a large and fluctuating number of users. The problem and the domain are not fully known. The solution is new and not easily uncovered. 10 | 11 | ## In This Context 12 | 13 | Automation is essential for success in cloud native, but people tend to try to create a full and automated solution in the beginning before real pain points are uncovered(taking an academic approach rather than experimental). This leads to automation of the wrong thing when the problem is not fully understood. Or,paraphrasing Bill Gates, who describes this conundrum as “Crap in, crap out,only faster.” 14 | 15 | - Universities teach to solve the problem in the “right” way. 16 | - Engineers prefer automation versus manual work. 17 | 18 | ## Therefore 19 | 20 | Understand the problem well, create a solution, make it work, and only then automate,scale, optimize, and improve.Before automating anything, first solve the problem manually. The team needs to seethe solution by doing it manually for a bit to experience and identify the pain points.Focus first on low-hanging fruit of automation (i.e., tasks that demand a lot of humantime and are easy to automate). 21 | 22 | - Run the process manually a few times. 23 | - Create a blueprint (a document with steps). 24 | - Do crude automation first (experiments, then an MVP version). 25 | - Optimize and scale. 26 | - Continually improve. 27 | 28 | ## Consequently 29 | 30 | Only the right things get automated. All the important and time-consuming tasks get automated eventually. 31 | 32 | {:.plusminus} 33 | - {:.plus} Scaled work becomes a well-understood process. 34 | - {:.minus} Process is manual for a while. 35 | -------------------------------------------------------------------------------- /_organization-culture/agile-for-new-development.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Agile for New Development 3 | description: Balance proficiency and innovation by building a separate time for each into your development cycle 4 | layout: pattern 5 | --- 6 | 7 | ![Agile for New Development]({{ site.baseurl }}/assets/images/agile%20for%20new%20development.png) 8 | 9 | Strategy is defined and solution direction is chosen after experimentation. There are still many uncertainties and not all knowledge is available within the team. 10 | 11 | ## In This Context 12 | 13 | Teams are either endlessly researching and collecting information or, conversely,starting to deliver and optimize very early. In the first case, value is delivered to customers late, ends up being of poor quality, or never gets delivered at all. In the . second case, the solutions are too simple and underdeveloped and miss the opportunity to solve customer problems. 14 | 15 | - Many processes aiming to increase productivity attempt to do so by pushing out innovation. 16 | - Radical innovation and proficient delivery can’t be done in the same way. 17 | - Innovation without delivery is academic research. 18 | - Delivery without innovation is blind to market changes. 19 | 20 | ## Therefore 21 | 22 | Run alternating iterations of research and development.Spend about 20%–30% of the time running proof-of-concept experiments and other research activities. Use the rest of the time to implement the discovered solutions and increase the quality. 23 | 24 | - Every third or fourth sprint in Scrum should be used for research. 25 | - 20%–30% of Kanban backlog should be dedicated to innovation and improvement tasks. 26 | - When a solution is not clear, use experiments or PoCs to discover and eliminate options. 27 | 28 | ## Consequently 29 | 30 | Delivery and innovation are separate and in balance. 31 | 32 | {:.plusminus} 33 | - {:.plus} Team can still change product direction relatively easily. 34 | - {:.plus} Quality of the products constantly increases. 35 | - {:.minus} One-third of the time is not immediately monetized. 36 | -------------------------------------------------------------------------------- /_operations/service-priority.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Service Priority 3 | description: Services should be assigned different priorities depending on its importance. 4 | layout: pattern 5 | --- 6 | 7 | ![Service Priority]({{ site.baseurl }}/assets/images/service_priority.png) 8 | 9 | You have deployed multiple applications in a dynamically orchestrated environment. In dynamic/cloud environment we want to over provision our infrastructure in order leverage dynamic nature of our applications to use our resources (CPU/Memory) as efficiently as possible. 10 | 11 | ## In This Context 12 | When resources (usually memory) are exhausted on a node/server our dynamic orchestration platform is forced to choose an application(s) to evict in order to avoid the entire node crashing. This can have negative effects if our critical applications are taken down. 13 | - The dynamic nature of our applications make prediction of resource usage difficult 14 | - We want to leverage the dynamic nature of our applications and utilization to over provision. 15 | - Certain applications react differently to unscheduled termination 16 | 17 | ## Therefore 18 | 19 | We can specify the relative priority of our different applications in order to pre-determine which ones will be evicted first. This allows us to protect our more critical services. 20 | 21 | ##### Actions 22 | - Determine which of our services are the most critical 23 | - Define priority levels for all services 24 | - Assign priorities with the platform 25 | - E.g. PodPriority in Kubernetes 26 | 27 | ## Consequently 28 | 29 | You can leverage over-provisioning of resources for efficent use of infrastrcucture whilst adding a measure of protection for critical services. 30 | 31 | {:.plusminus} 32 | - {:.plus} All services will be assigned a priority. 33 | When resources are exhausted on a node, the orchestration platform is able to make more intelligent decisions about which applications to kill/reschedule 34 | - {:.plus} When higher priority services are needed to be scheduled, and sufficient resources are not currently available, the orchestration platform is able to evict lower priority applications to make space. 35 | -------------------------------------------------------------------------------- /_development-design/developer-starter-pack.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Developer Starter Pack 3 | description: Provide a “starter kit” of materials, guides, and other resources to help new teams onboard to the new cloud native system quickly and with confidence 4 | layout: pattern 5 | --- 6 | 7 | ![Developer Starter Pack]({{ site.baseurl }}/assets/images/DEVELOPER%20STARTER%20PACK.png) 8 | 9 | The new cloud native platform is approaching production-ready status, and it’s time to begin onboarding teams. 10 | 11 | ## In This Context 12 | 13 | Teams onboarding to cloud native don’t know the tools or technologies and typically receive poor onboarding materials. At best, this leads to wasted time, and at worst, teams are forced to create their own cloud native practices, which are uninformed,not designed for this platform, and not uniform. 14 | 15 | - There are limited publicly available materials. 16 | - People will use known techniques if they are not provided with clear guidance to new ones. 17 | - If teams are onboarded with insufficient training, they will overload the support team with requests for help. 18 | - People tend to accept default choices, so giving them good defaults increases overall quality. 19 | 20 | ## Therefore 21 | 22 | Provide developers onboarding to cloud native everything they need to start working immediately.Optimally, new developers should be able to commit their first change and deploy it to the test environment on the first day following the onboarding. 23 | 24 | - This cloud native “starter kit” of materials should include tool configurations,version control repository, CI/CD pipelines, demo applications for practice, targetplatform description, trainings, and more. 25 | - All of this needs to be prepared before the next step of onboarding. 26 | 27 | ## Consequently 28 | 29 | Cloud native practices are adopted as the Core Team has planned, and there is consistency. 30 | 31 | {:.plusminus} 32 | - {:.plus} Less work and fewer problems for the Core Team after onboarding, because the newly onboarded developers have the tools and confidence to solve their own problems. 33 | - {:.minus} Less freedom for learning by doing for the dev teams. 34 | -------------------------------------------------------------------------------- /_operations/gitops.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: GitOps 3 | description: Use Git as a single source of truth for infrastructure configuration 4 | layout: pattern 5 | --- 6 | 7 | ![GitOps]({{ site.baseurl }}/assets/images/gitops.png) 8 | 9 | Following Infrastructure-as-Code practices your infrastructure is defined as code. 10 | 11 | ## In this Context 12 | 13 | You want to deliver changes quicker, but require security and reliability. How do you coordinate application delivery and infrastructure management in a controlled, secure manner without reducing velocity? 14 | 15 | - Multiple tools, technologies 16 | - Changing landscape (deployment environments, clusters, etc) 17 | - Often need multiple clusters and deployment environments 18 | - Manual actions are slow and error prone 19 | 20 | ## Therefore 21 | 22 | Use a Git repository to store the current (desired) state of your infrastructure and applications in production. An in cluster service to monitor the repository and adjust the current state as needed. 23 | 24 | - Store all infrastructure configuration in a declarative format in a Git repository 25 | - Deploy a service (operator) into your cluster to monitor repo and apply changes 26 | - All infrastructure changes are made via branch/pull requests on the repository 27 | 28 | ## Consequently 29 | 30 | You get the single source of truth about your infrastructure and an easy way to audit changes to it. 31 | 32 | {:.plusminus} 33 | - {:.plus} We end up with a single source of truth for the (desired) state our infrastructure and applications 34 | - {:.plus} We use existing (tested) tools (Git) and workflows for managing changes to our system. 35 | - {:.plus} We can much more easily scale out, e.g. to multiple clusters environments. 36 | - {:.plus} We have a built-in approval process and auditing of all changes. 37 | - {:.minus} All manual access and changes must be removed. This needs to be enforced and requires education across teams. 38 | - {:.minus} Secret management is quite challenging and very often requires use of 3rd party tools. 39 | - {:.minus} Not designed for programmatic updates, multiple CI processes can end up writing to the same GitOps repo, causing conflicts. 40 | 41 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/periodic-checkups.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Periodic Checkups 3 | description: Frequently reassess vision and objectives to ensure these remain the correct direction to proceed as the business environment shifts 4 | layout: pattern 5 | --- 6 | 7 | ![Periodic Checkups]({{ site.baseurl }}/assets/images/periodic%20check-ups.png) 8 | 9 | The company is immersed in the new and changing environment of cloud native.Goals and strategy are set, the Core Team is underway, and the transformation is going full speed ahead. But the business goals might be changing as the environment changes. 10 | 11 | ## In This Context 12 | 13 | Teams focused solely on execution without pausing to assess and re appraise the direction they’re going in might achieve what they originally planned—but not what they ultimately needed, because circumstances changed along the way. 14 | 15 | - Teams tend to work by creating strategy, choosing a direction, and then continuing on without reviewing changes in environment or goals. 16 | - Visions and plans require adjustment to meet real-world conditions. In the words of German military strategist Helmuth von Moltke, “No battle plan survives contact with the enemy.” 17 | - Cloud native ecosystem changes quickly, with new tech emerging all the time. 18 | - It is impossible to predict what the cloud native world will look like in a year. 19 | - Under delivery pressure, teams don’t have a chance to look around them, only straight ahead. 20 | - The process itself may require adjustments as the team matures. 21 | 22 | ## Therefore 23 | 24 | Make sure that you and your team are still on the right path. Assess the current situation with regard to initial strategic decisions. 25 | 26 | - Run a gap analysis assessment every month during the transformation. 27 | - Have a standard assessment template. 28 | - Invite independent experts to provide a second opinion. 29 | 30 | ## Consequently 31 | 32 | The Core Team meets regularly to assess current conditions and can adjust direction as circumstances require. 33 | 34 | {:.plusminus} 35 | - {:.plus} Time to reflect and celebrate progress. 36 | - {:.minus} Frequent adjustments may distract from overall delivery. 37 | -------------------------------------------------------------------------------- /patterns-library.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Patterns Library 3 | description: Designs to help map a Cloud Native transformation 4 | layout: default 5 | --- 6 | 7 | # Pattern Families 8 | 9 | You don’t need to know much, if anything, about the cloud to use Cloud Native patterns. When designing a house, you tell the architect what you want—but that doesn’t mean you have to build it yourself. Patterns are just high-level plans for what you want to create. 10 | 11 | We’ve organized Cloud Native patterns into four different families. Patterns from these different groups can be applied at any point in a transformation design, or patterns within a single family can be used to drill down and create a very detailed design for a particular stage in a transformation initiative. (For instance: Strategy & Risk Reduction patterns might be most useful in the early planning stages of a transformation.) 12 | 13 |
14 | 15 | {:.col-sm .d-flex .flex-column} 16 | [Strategy & Risk Reduction]({{ site.baseurl }}/strategy-risk-reduction)[![Strategy & Risk Reduction]({{ site.baseurl }}/assets/images/Asset%2045.png){:height="410px" width="300px"}]({{ site.baseurl }}/strategy-risk-reduction) 17 | 18 | {:.col-sm .d-flex .flex-column} 19 | [Organization & Culture]({{ site.baseurl }}/organization-culture)[![Organization & Culture]({{ site.baseurl }}/assets/images/Asset%2044.png){:height="410px" width="300px"}]({{ site.baseurl }}/organization-culture) 20 | 21 | {:.col-sm .d-flex .flex-column} 22 | [Development & Design]({{ site.baseurl }}/development-design)[![Development & Design]({{ site.baseurl }}/assets/images/Asset%2047.png){:height="410px" width="300px"}]({{ site.baseurl }}/development-design) 23 | 24 | {:.col-sm .d-flex .flex-column} 25 | [Infrastructure & Cloud]({{ site.baseurl }}/infrastructure-cloud)[![Infrastructure & Cloud]({{ site.baseurl }}/assets/images/Asset%2043.png){:height="410px" width="300px"}]({{ site.baseurl }}/infrastructure-cloud) 26 | 27 | {:.col-sm .d-flex .flex-column} 28 | [Operations]({{ site.baseurl }}/operations)[![Operations]({{ site.baseurl }}/assets/images/Operations-patterns.png){:height="410px" width="300px"}]({{ site.baseurl }}/operations) 29 |
30 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/value-hierarchy.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Value Hierarchy 3 | description: When an organization’s values are clearly stated and prioritized, as well as fully internalized across the company, people have the basis for making day-to-day decisions without needing to seek consent or permission/approval 4 | layout: pattern 5 | --- 6 | 7 | ![Value Hierarchy]({{ site.baseurl }}/assets/images/value%20hierarchy.png) 8 | 9 | The company’s cloud native transformation has just begun, and there is a lot of uncertainty. People are still learning about the tech, and the organizational structureis evolving. Teams are becoming independent, and there are many moving pieces. 10 | 11 | ## In This Context 12 | 13 | Without a clear understanding of the company values and the priorities, people have no easy way to connect their daily work to the company strategy. In such a situation, different teams may make conflicting decisions or waste a lot of effort on low-priority tasks. 14 | 15 | - Gaining consensus from all stakeholders is time-consuming. 16 | - In traditional organizations managers make all the decisions. 17 | - The market is changing frequently, with new competitors appearing unexpectedly. 18 | - Cloud native technology is constantly and rapidly evolving. 19 | 20 | ## Therefore 21 | 22 | Create an ordered list of clearly stated values to simplify decision making and guide behavior in an uncertain environment. 23 | 24 | - Identify the company’s values: what is important to us? 25 | - Formulate these simply and clearly. 26 | - Rank these values in order of importance. 27 | - Incorporate this value hierarchy into the company’s culture and identity by broadcasting it across the organization. 28 | 29 | ## Consequently 30 | 31 | Teams and individuals in an organization are able to make decisions with confidence. 32 | 33 | {:.plusminus} 34 | - {:.plus} Organizational principles and priorities are clear and commonly understood by all. 35 | - {:.plus} People can easily make informed choices that reflect both the company’s values and best interest. 36 | - {:.plus} In a constantly changing environment, there is a stable and constant point of orientation. 37 | - {:.minus} Too-frequent changes to the value hierarchy can cause confusion and chaos. 38 | -------------------------------------------------------------------------------- /_infrastructure-cloud/containerized-apps.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Containerized Apps 3 | description: When an application is packaged in a container with all its necessary dependencies, it does not rely on the underlying runtime environment and so can run agnostically on any platform 4 | layout: pattern 5 | --- 6 | 7 | ![Containerized Apps]({{ site.baseurl }}/assets/images/containerized%20apps.png) 8 | 9 | The team is building a distribution app that can scale up and down. Separate teams are meanwhile building microservices, and they need to take them quickly through a variety of dev and test environments all the way to production. There are a variety of different runtime environments, such as personal laptops, during development and different private and public clouds for testing, integration, and production. 10 | 11 | ## In This Context 12 | 13 | Speed of delivery can be slow if an app depends on uniformity among different environments. Maintaining consistency of different tools and their versions on many machines across many on-premises and/or public clouds is difficult, time consuming,and risky. 14 | 15 | - All stable environments tend to drift eventually. 16 | - It’s impossible to manage thousands of machines manually. 17 | - Differences in environment are difficult to find and to fix. 18 | 19 | ## Therefore 20 | 21 | Package up an application’s code and everything it needs to run (all its dependencies,runtime, system tools, libraries, and settings) as a consistent unit so the application can be distributed to start up quickly and run reliably in any computing environment.This minimizes dependency on the runtime environment. Build once, run everywhere,and distribute quickly and easily. 22 | 23 | - Use industry standards like Docker. 24 | - Ensure proper versioning and simple and quick distribution. 25 | - All dependencies included. 26 | - All environments use the same basic tooling. 27 | - Ensure that containers can run on local or any other environment. 28 | 29 | ## Consequently 30 | 31 | Every part of the app is packaged in a container and can be easily started anywhere. 32 | 33 | {:.plusminus} 34 | - {:.plus} Container tools like Docker improve efficiency. 35 | - {:.minus} Large numbers of separate containers increase system complexity. 36 | - {:.minus} Managing container images requires extra effort. 37 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/vision-first.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Vision First 3 | description: Defining a high-level transformation path as the very first step helps set the right course through an uncertain environment 4 | layout: pattern 5 | --- 6 | 7 | ![Vision First]({{ site.baseurl }}/assets/images/vision%20first.png) 8 | 9 | The company has established a Business Case for going cloud native, achieved Executive Commitment, and is ready to move forward with a transformation initiative. 10 | 11 | ## In This Context 12 | 13 | The company needs to define a clear and achievable vision that can be translated into specific executable steps. 14 | 15 | - Without an overall consistent vision, different teams will make independent and,frequently, conflicting architectural decisions. 16 | - The combination of limited experience and lack of extra time and flexibility for research leads to pursuing cloud native implementation using “well-known ways.” 17 | - In many companies, enterprise architects are responsible for creating a detailed architecture. Many enterprise architects lack sufficient theoretical or practical experience in the cloud native approach. 18 | - Agile methodologies, widely adopted in the contemporary business world, create pressure to produce results early and onboard teams to new systems very quickly. 19 | 20 | ## Therefore 21 | 22 | Define and visualize the organizational structure and architecture of the whole system upfront. 23 | 24 | - This can be either requested from external sources or uncovered by a series of small research and prototyping projects ranging from a few hours to a few days each. 25 | - Keep the vision high-level to allow freedom of choice during implementation(not dictating specific tools or approaches) yet also specific enough to provide clear goals and desired outcomes. 26 | - Revisit the vision regularly to evaluate status and adjust the plan if necessary. 27 | - Executive Commitment paired with leadership by the Transformation Champion are essential for successful vision creation—this indicates the path for the teams to follow. 28 | 29 | ## Consequently 30 | 31 | All teams have a clear guiding principle for the implementation phase. 32 | 33 | {:.plusminus} 34 | - {:.plus} The teams can start producing the lower-level architecture and translate it to the backlog of tasks. 35 | -------------------------------------------------------------------------------- /_operations/network-isolation.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Network Isolation 3 | description: Leverage a tool to provide more granular control over connections to workloads. 4 | layout: pattern 5 | --- 6 | 7 | ![Network Isolation]({{ site.baseurl }}/assets/images/network%20issolation.png) 8 | 9 | An organisation is utilising a container platform which runs multiple different systems, environments, shared by multiple teams or even customers. 10 | 11 | ## In This Context 12 | 13 | Multiple applications, teams, environments (e.g. dev/staging) and even clients (multi tenant) are sharing the platform. While these separate services should not normally access each other across certain boundaries (e.g. Namespaces), 14 | by default there is nothing blocking traffic (either malicious or by error) from crossing these boundaries. 15 | Separate applications running on one platform can be susceptible to attacks from others. 16 | 17 | ## Therefore 18 | 19 | By leveraging a feature such as NetworkPolicies in Kubernetes, we can block all unwanted traffic between services. 20 | 21 | #### Actions 22 | - Determine all expected traffic between your services. (A service mesh or tracing tool can generate this dynamically). 23 | - Define rules to block all (other) traffic between services. 24 | - Apply the created rules and monitor your applications for any problems created. 25 | - (Optional) add logging for all blocked traffic 26 | - For any unforeseen traffic, determine if it is a) intended or b) undesired
27 | a) -> Add a rule to allow the traffic, update your network topology
28 | b) -> Fix the application making the undesired access 29 | 30 | ## Consequently 31 | 32 | Network security is enhanced within the shared platform with the ability to track subsequent changes. 33 | 34 | {:.plusminus} 35 | - {:.plus} We have created a much more secure solution. 36 | - {:.plus} For any attacker who manages to compromise a service they are now severely limited in terms of damage they can due (#defenceInDepth) 37 | - {:.plus} We are protected against mistakes made in development accessing services which should not be 38 | - {:.plus} We have a clear and auditable picture of the actual network traffic on our environment 39 | - {:.minus} Each change in the source, destination traffic must be configured in the network isolation tool 40 | -------------------------------------------------------------------------------- /_organization-culture/lean-for-optimization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Lean for Optimization 3 | description: When a stable system delivers the value that’s intended and is not a target for technical innovation, focus on improving the system by continuously and incrementally improving delivery and maintenance processes with emphasis on repeatability 4 | layout: pattern 5 | --- 6 | 7 | ![Lean for Optimization]({{ site.baseurl }}/assets/images/Internal%20evangelism_.png) 8 | 9 | Your product is stable and in demand (a “Cash Cow” on the BCG growth-share matrix), and it is in a state of incremental improvement and support. Tech used in the product is known and well-understood. All capabilities are present in the team. 10 | 11 | ## In This Context 12 | 13 | Innovation and evolution are inevitable in technology. However, there is little need to innovate when a proficient system is delivering stable value and maintenance cost is low. And we often see that, in an otherwise proficient system, the team continues to introduce new tools and solutions that constantly destabilize the product while needlessly consuming time and budget. 14 | 15 | - Repeatability leads to boredom. 16 | - Quality demands investment. 17 | - Creativity and proficiency require different management frameworks. 18 | - Proficiency and mastery require repeatability and standards. 19 | - Creativity requires freedom and psychological safety for generating experimentation. 20 | 21 | ## Therefore 22 | 23 | Reduce work in progress, focus on optimizing delivery process, measure quality and speed of delivery, and aim to improve both.Lean management optimizes proficiency and value to customers while eliminating anything that does not bring value to the end product/service and ensuring continuous incremental improvement. 24 | 25 | - Use Kanban with optimization and new features backlog. 26 | - Measure everything that matters. 27 | - Optimize price versus performance ratio. 28 | - Optimize proficient processes. 29 | - Automate repeatable tasks. 30 | 31 | ## Consequently 32 | 33 | Delivery is fast and proficient. System is stable, and quality is consistently going up. 34 | 35 | {:.plusminus} 36 | - {:.plus} No destruction of an efficient system. 37 | - {:.plus} Gradually increasing quality. 38 | - {:.minus} Very limited innovation. 39 | - {:.minus} Some people are bored. 40 | -------------------------------------------------------------------------------- /_operations/customization-through-microservices.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Customization Through Microservices 3 | description: Use a customization API to handle customizations 4 | layout: pattern 5 | --- 6 | 7 | ![Customization Through Microservices]({{ site.baseurl }}/assets/images/saas.png) 8 | 9 | In a cloud based (SaaS) application, customization is generally an anti-pattern. However, there are certain areas, such as ERP and CRM platforms, where this is an essential feature of the system. A company with such a product, looking to migrate to a modern, SaaS, platform must be able to offer the same customization features to their customers. 10 | 11 | ## In This Context 12 | 13 | The goal of a SaaS platform is to leverage multi-tenancy, that is all users of the system share the same platform. How then can we have custom code for each customer? Adding the custom code into the main application, as is usually done with legacy applications which are run on client's own servers, is not a viable option in a multi-tenant SaaS model. 14 | 15 | - Custom code and features can quickly bloat a code base, as more clients are added. 16 | - Isolating custom logic from each customer is challenging. 17 | - High risk of customization code impacting the core functionality. 18 | - Custom code is usually developed by a separate team, this cannot be able to affect other customers. 19 | 20 | ## Therefore 21 | 22 | By creating a well defined 'customization' interface (API), customer specific microservices can be created to execute all custom logic. The custom microservices are only called at designated points, and routing is handled by an internal API gateway or service mesh. 23 | 24 | ## Consequently 25 | 26 | Customization can be offered to customers without negatively impacting the core services or other customers. 27 | 28 | {:.plusminus} 29 | - {:.plus} Custom code is well contained within it's own microservice. 30 | - {:.plus} If the custom code breaks it does not affect other users. 31 | - {:.plus} We can set network boundaries, and resource limits on the custom microservices to create the necessary level of isolation. 32 | - {:.plus} The core services need have no knowledge of the custom logic or microservices. 33 | - {:.minus} This pattern can result in a increase in network traffic, and as a result latency as the amount of customization increases. 34 | 35 | 36 | -------------------------------------------------------------------------------- /_infrastructure-cloud/public-cloud.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Public Cloud 3 | description: Instead of using your own hardware, rely on the hardware managed by public cloud vendors whenever possible 4 | layout: pattern 5 | --- 6 | 7 | ![Public Cloud]({{ site.baseurl }}/assets/images/public%20cloud%20.png) 8 | 9 | You are moving to microservices, you are continuously growing your codebase, and teams now require automation for Continuous Delivery. The amount of manual workis going down, but the cost of maintaining hardware is going up. 10 | 11 | ## In This Context 12 | 13 | Procuring, installing, and maintaining hardware becomes a bottleneck that slowsdown the entire organization .For most businesses, infrastructure and hardware are not their core business, so they do not invest heavily in maintaining and improving them. Public cloud vendors, however, invest a great deal of money and talent to optimize their services. Furthermore, when you own the hardware, costs are typically higher: you need to overprovision for peak consumption. If Black Friday traffic is 10 times higher, thenyou must maintain that 10-times capacity the other 364 days of the year—there is noelastic capacity expansion. 14 | 15 | - Private clouds quickly become outdated because they are not a high priority for the business. 16 | - Never enough resources to make a private cloud as good as public cloud. 17 | - In some business areas regulations may not allow use of public cloud due to security concerns and explicit data regulation. 18 | 19 | ## Therefore 20 | 21 | Hand over the management of hardware and rent capacity from public cloud vendors like Amazon, Microsoft, Google, and similar instead of owning, managing,and creating full automation for infrastructure. 22 | 23 | - Rely on full automation. 24 | - Use APIs to connect with public cloud. 25 | 26 | ## Consequently 27 | 28 | You rent fully automated, scalable, resilient infrastructure from a public cloud provider that can be increased and decreased on demand. You pay only for the resources you are actually using. 29 | 30 | {:.plusminus} 31 | - {:.plus} Take advantage of integrated services. 32 | - {:.plus} Public cloud vendors constantly upgrading to latest software and services. 33 | - {:.plus} Built-in services like maintained databases, machine learning frameworks, and all kinds of SaaS continuously being built by the vendors. 34 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/measure-what-matters.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Measure What Matters 3 | description: People optimize their actions based on how their work is measured. Assessing the wrong things leads people to optimize for the wrong goals 4 | layout: pattern 5 | --- 6 | 7 | ![Measure What Matters]({{ site.baseurl }}/assets/images/measure%20what%20matters.png) 8 | 9 | The company has strategic and tactical goals, and the management team wants to establish company performance metrics to measure and monitor progress. 10 | 11 | ## In This Context 12 | 13 | People tend to optimize their work output based on what is measured. Incorrect measurements will result in flawed deliveries (delivering the wrong things) and suboptimal performance.For example, measuring velocity in Scrum will lead to inflation of story points. If the key performance indicator (KPI) doesn’t reflect the company’s actual needs, the result will be poor. This is an example of Goodhart’s law, which states “When a measure becomes a target, it ceases to be a good measure.” What happens is that which this can occur is individuals trying to anticipate the effect of a policy and then taking actions that alter its outcome. 14 | 15 | - People tend to optimize for best measurements. 16 | - Most methodologies bring their own metrics. 17 | - Different teams may have different goals. 18 | 19 | ## Therefore 20 | 21 | Always adjust performance measurements to fit the organization’s strategic and tactical needs. Keep measuring the most important KPI and stop when specific behavior becomes routine. Only measure a few KPIs at a time, choosing ones related to the current worst bottlenecks. Prioritizing customer value as the main metric helps to focus on customer needs. 22 | 23 | - Keep KPIs measurable and achievable but also stretched for delivery progress. 24 | - Measure differently for creativity versus proficiency. 25 | - Avoid getting stuck in vanity metrics like number of site visitors and focus on measuring customer value. 26 | 27 | ## Consequently 28 | 29 | Managers set up KPIs in conjunction with goals and adjust them as the goals are changing. 30 | 31 | {:.plusminus} 32 | - {:.plus} Higher awareness from all involved. 33 | - {:.plus} All stakeholders have more clarity about priorities and goals. 34 | - {:.minus} It is difficult—and confusing to the teams—if metrics change frequently. 35 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/executive-commitment.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Executive Commitment 3 | description: To ensure allocation of sufficient resources and reasonable delivery time frames, large scale projects such as cloud native transformation require strong commitment from the top executive team 4 | layout: pattern 5 | --- 6 | 7 | ![Executive Commitment]({{ site.baseurl }}/assets/images/executive%20commitment.png) 8 | 9 | An enterprise that is using Waterfall or Agile software development practices has made a clear decision to adopt cloud native, with a business case supporting the transformation. 10 | 11 | ## In This Context 12 | 13 | Cloud native transformations require significant changes in all areas of an organization,from infrastructure to processes to culture. These changes place large demands on the organization’s budget and time. 14 | 15 | - Clients continue demanding fast delivery of new functionality, leaving no slack for structural changes. 16 | - Executive performance is measured by P&L (profit and loss statement), reducing incentives to invest in long-term structural improvement such as cloud native transformation. 17 | - Executives likely don’t understand the full scope of the cloud native transformation. 18 | - Successful adoption of cloud native may significantly speed up feature development and increase tech teams’ job satisfaction. 19 | 20 | ## Therefore 21 | 22 | Announce the cloud native transformation as a high-priority strategic initiative that is important to the company and that has explicit support from the executive management. 23 | 24 | - {:.plus} Prepare a transformation strategy and the allocation of adequate resources and budget. 25 | - {:.plus} Publicly announce the cloud native transformation as a strategic initiative. This creates company-wide alignment and awareness, while setting the expectation of collaboration from all departments. 26 | 27 | ## Consequently 28 | 29 | The company is aligned around common goals and everyone understands priorities for the transformation. 30 | 31 | {:.plusminus} 32 | - {:.plus} All departments follow a unified vision, thus avoiding independent silos that lead to inconsistent, or even conflicting, implementation. 33 | - {:.minus} Personal public commitment by execs makes it difficult for them to reverse the decision later, due to public embarrassment related to changing their minds. 34 | -------------------------------------------------------------------------------- /_development-design/continuous-integration.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Continuous Integration 3 | description: Frequent integration of small iterative changes speeds overall delivery and improves the quality of the code 4 | layout: pattern 5 | --- 6 | 7 | ![Continuous Integration]({{ site.baseurl }}/assets/images/continuous%20integration.png) 8 | 9 | Many developers are working within the same codebase and need to integrate their changes. 10 | 11 | ## In This Context 12 | 13 | When a team of developers works on a set of features that integrates only when all features are finished, the integration process tends to be very complex. The code base change is large, and in the meantime other devs have integrated separate large changes that can further complicate the integration. To increase productivity,devs often delay interim integration—which leads to a single “big bang” integration just prior to release. A minor bug or conflict that could have been easily caught in an interim integration can now end up delaying the entire release. 14 | 15 | - Memory of the change you made fades with time, so delayed integration can increase difficulties. 16 | - Chance of conflicts is smaller when the change is small. 17 | - Frequent execution of the same task creates incentives for automation. 18 | - It is very easy to lose trust in the system if reports are not available. 19 | 20 | ## Therefore 21 | 22 | All developers integrate their changes at least once per day. Integration of all changes is done on a main codebase for each microservice. Code differences are small, less than one day of work, which leads to simpler integration.The main codebase is continually rebuilt and tested to ensure that every developer has functioning and up-to-date code to work with, which minimizes unexpected conflicts with any other newly integrated code. 23 | 24 | - Introduce test automation and unit tests. 25 | - Build each change and test it immediately. 26 | - Immediately fix any broken build. 27 | - Commit to the same mainline on the codebase. 28 | - Must have good reporting. 29 | - Use feature toggling. 30 | 31 | ## Consequently 32 | 33 | Integration is a nonevent. Products are always in a releasable state. 34 | 35 | {:.plusminus} 36 | - {:.plus} Code is always good-quality, tested, and functional. 37 | - {:.plus} Collaboration is easier. 38 | - {:.plus} Minor bugs and conflicts are caught before they cause major problems. 39 | - {:.minus} There is some overhead. 40 | -------------------------------------------------------------------------------- /_development-design/communicate-through-apis.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Communicate Through APIs 3 | description: In a highly distributed system, microservices must communicate with one another via stable and strongly segregated APIs 4 | layout: pattern 5 | --- 6 | 7 | ![Communicate Through APIs]({{ site.baseurl }}/assets/images/Communicate%20through%20API.png) 8 | 9 | A company is building a microservices application. Some teams work on a single microservice, others on multiple microservices. Teams are independent and aim to reduce inter team dependencies on both technical and organizational levels. 10 | 11 | ## In This Context 12 | 13 | If APIs among microservices are not well-defined and fully segregated, they will require tighter coupling in development and/or delivery. This in turn introduces dependency, both service-to-service and among teams on an organizational level.This process essentially undoes the move to decouple the monolithic app in the first place, as it leads to coordinated development for the delivery of multiple services and requires very tight collaboration across teams.This reduces the speed and agility of the organization and effectively re-creates the original monolithic architecture and organizational structure. 14 | 15 | - Tight coupling begins with a simple decision to share data directly. 16 | - Conway’s law: a software application’s architecture will evolve to mirror the organizational structure of the company producing it. 17 | - A single team working on multiple microservices may take shortcuts and introduce tight coupling. 18 | 19 | ## Therefore 20 | 21 | Microservices should communicate with one another only through the network,using simple, consistent, and stable APIs. 22 | 23 | - Build stable APIs with backward compatibility. 24 | - Place most of the service logic within the service itself, keeping the API simple and easily maintainable. 25 | - Smart endpoints, dumb pipes (most of the business logic is in the microservices themselves and not in the APIs). 26 | - Ensure each microservice has no direct access to data of other microservices. 27 | - Make sure there is version control and version management for APIs. 28 | 29 | ## Consequently 30 | 31 | Microservices are kept decoupled and independent. 32 | 33 | {:.plusminus} 34 | - {:.plus} Old microservices can easily be replaced when needed as long as APIs are preserved. 35 | - {:.minus} Communication through network can be slower and is more complex to architect. 36 | -------------------------------------------------------------------------------- /_development-design/automated-testing.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Automated Testing 3 | description: Shift responsibility for testing from humans (manual) to automated testing frameworks so the quality of the released products is consistent and continuously improving, allowing developers to deliver faster while spending more of their time improving features to meet customer needs 4 | layout: pattern 5 | --- 6 | 7 | ![Automated Testing]({{ site.baseurl }}/assets/images/automated%20testing.png) 8 | 9 | CI and CD are in progress. Legacy code is being refactored to MS, and the team is aiming to deliver changes a few times a day. 10 | 11 | ## In This Context 12 | 13 | Humans are too slow and inconsistent to be a blocking factor in the pipeline for deployment to production.Any human handover or task performed by a human will significantly reduce the number of changes a team can deliver and increase the time required to deliver them. 14 | 15 | - Humans can never be as fast as computers. 16 | - Poor testing quality undermines trust in the delivery process, and testing is a waste of time. 17 | - People tend to delay and combine changes if each delivery is risky. 18 | - When tests are slow, people tend to avoid running them as frequently as they should. 19 | 20 | ## Therefore 21 | 22 | Automate all the testing required to take any product change to production.Most functionality should be tested using fast and local unit tests, integration tests can ensure that components are working well together, and only a small portion of the test coverage needs to be on the system UI levels. All long-running and manual tests should be gradually refactored and automated, and they should not block consistent flow of changes to production. 23 | 24 | - Use testing pyramid. 25 | - Long tests should not block release. 26 | - Manual and long-running processes happen only in background. 27 | - Continuously add and change tests. 28 | - Consider test-driven development. 29 | - Add advanced in-product testing like A/B, canary, blue/green, etc. 30 | 31 | ## Consequently 32 | 33 | The team can trust that the delivery process will catch most issues and that changes will flow to production quickly. 34 | 35 | {:.plusminus} 36 | - {:.plus} The team is ready to deliver changes and take the risks. 37 | - {:.plus} Developers write tests, which gives deeper insight into the code. 38 | - {:.minus} If there is a team in charge of manual testing, they may need to be retrained for new responsibilities. 39 | -------------------------------------------------------------------------------- /_development-design/microservices-architecture.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Microservices Architecture 3 | description: To reduce the costs of coordination among teams delivering large monolithic applications,build the software as a suite of modular services that are built, deployed, and operated independently 4 | layout: pattern 5 | --- 6 | 7 | ![Microservices Architecture]({{ site.baseurl }}/assets/images/microservices%20architecture.png) 8 | 9 | A company has decided to move to cloud native and is looking at ways to speed up feature development and to optimize their use of cloud resources. The size of the development/engineering staff can range from a few tens, for a small to medium business, up to a few thousand for a large enterprise. 10 | 11 | ## In This Context 12 | 13 | Delivery of large monolithic applications developed by large teams require long and complex coordination and extensive testing, leading to longer TTM (Time to Market). Hardware use by such applications is inefficient, which leads to wasted resources. 14 | 15 | - People tend to delay painful moments; since integration and delivery are typically painful, their frequency tends to decrease as system longevity increases. 16 | - Larger monolithic systems are increasingly difficult to understand as they grow in size and complexity. 17 | - Monoliths are easier to work with than modular applications as long as they are small enough to be understood by each developer. 18 | - Tiny monoliths (not big ones) are often the quickest, simplest solution to relatively easy problems. 19 | - Conway’s law: architecture tends to resemble the organizational structure. 20 | 21 | ## Therefore 22 | 23 | Split applications into smaller, loosely coupled microservices that can be built,tested, deployed, and run independently from other components. 24 | 25 | - Small and independent teams work on separate modules and deliver them with only limited coordination across the teams. 26 | - Independent components allow different teams to progress at their own pace. 27 | 28 | ## Consequently 29 | 30 | New systems are created from many small and independently built components with a complex web of connections. 31 | 32 | {:.plusminus} 33 | - {:.plus} Faster-moving teams are not held back by slower ones. 34 | - {:.plus} Teams can choose the most appropriate tools for delivering their particular service. 35 | - {:.minus} Independence and freedom of choice are achieved, but with the tradeoffs of reduced standardization and certain types of reusability. 36 | -------------------------------------------------------------------------------- /_infrastructure-cloud/full-production-readiness.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Full Production Readiness 3 | description: Make sure your platform is fully provisioned with CI/CD, security, monitoring, observability,and other features essential to production readiness before you try to take it live 4 | layout: pattern 5 | --- 6 | 7 | ![Full Production Readiness]({{ site.baseurl }}/assets/images/Full%20production%20readiness.png) 8 | 9 | Core Team is stepping up the cloud native platform. The new platform and the first few applications moving over to it are scheduled for full production delivery very soon. 10 | 11 | ## In This Context 12 | 13 | Too many companies try to rush their newly built cloud native platform into production before it is really ready. Typically the container scheduling platform isinstalled, but it’s still missing essential automation elements around maintenance and software delivery. This leads to poor quality of the running system and necessitates long delivery cycles. Many times the platform vendor will confirm production readiness of their tool—but without considering the whole system of delivery and maintenance cycles that are an equally crucial part of production. 14 | 15 | - Typical cloud native platforms today include only a partial platform and require significant additional configuration and automation. 16 | - A typical full cloud native platform includes 10 to 20 tools. 17 | - Once the main platform is fully running, there is pressure to deliver. 18 | - In case of poor maintenance automation, platform teams could be overloaded with support tasks as teams onboard. 19 | 20 | ## Therefore 21 | 22 | Before going to production all major elements of the platform, as well as those of any applications initially migrating to it, need to be in place. This includes havinga scheduler, observability, security, networking, storage, and CI/CD. Also, at least basic maintenance automation must be in place. 23 | 24 | - System is automated. 25 | - Maintenance is automated or at least documented. 26 | - A bare and basic MVP version of a platform is not enough: there must also be observability, CI/CD, security, etc. 27 | 28 | ## Consequently 29 | 30 | The new platform is functional and maintainable, and major tasks are automated.The Platform Team can continue extending the platform while providing satisfactory support for the development teams using it. 31 | 32 | {:.plusminus} 33 | - {:.plus} All major elements of the platform are in place. 34 | - {:.minus} May delay release to production. 35 | -------------------------------------------------------------------------------- /_development-design/distributed-systems.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Distributed Systems 3 | description: When software is built as a series of fully independent services, the resulting system is,by design, fast, resilient, and highly scalable 4 | layout: pattern 5 | --- 6 | 7 | ![Distributed Systems]({{ site.baseurl }}/assets/images/distributed%20systems.png) 8 | 9 | System complexity has grown beyond the capabilities of the key architects to understand it, but additional growth is still required. 10 | 11 | ## In This Context 12 | 13 | Once the system has grown beyond the capacity of a single architect/engineer to understand, it becomes difficult and time-consuming to add functionality. With the growth of the old software systems, more people join the team and the system constantly collects technical depth, which leads to fragility and unpredictable side effects that come with every change. This creates fear of adding new functionality and stagnates development. 14 | 15 | - Human mental capacity for grasping complex systems is finite. 16 | - Monolithic systems require someone with full understanding of the complex relationships among components to make/approve any changes to the system. 17 | - Almost all software systems start out as small monoliths. 18 | 19 | ## Therefore 20 | 21 | Build the software system as a number of independent components (microservices)running on different computers and communicating through APIs. Development,delivery, and scheduling of each component is completely independent, andany component can fail without affecting the others.Distributed systems are much more complex to initially architect and implement, but once that initial work is invested they are much simpler to grow—and evolve with improvements, new features, and changes. 22 | 23 | - Split the system into small pieces (microservices components). 24 | - Define APIs. 25 | - Use more, but simple, computers that are less expensive and easy/fast to provision.Public clouds are most effective. 26 | 27 | ## Consequently 28 | 29 | Higher complexity through many decoupled components makes a more resilient and scalable system. Each component can become more complex until it is divided into smaller independent pieces to allow the system to grow indefinitely in scale and complexity. 30 | 31 | {:.plusminus} 32 | - {:.minus} At this level of complexity truly no one is capable of fully understanding the system, which makes it difficult to maintain. 33 | - {:.plus} High levels of automation and good observability help prevent problems. 34 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/data-driven-decision-making.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Data-Driven Decision Making 3 | description: Collect data, extract patterns and facts, and use them to make inferences to drive objective decision making 4 | layout: pattern 5 | --- 6 | 7 | ![Data-Driven Decision Making]({{ site.baseurl }}/assets/images/data-driven%20decision%20making.png) 8 | 9 | A company is moving to cloud native and sees the complexity and number of components growing exponentially. Each component is built separately. Competitors are changing products on a daily basis. 10 | 11 | ## In This Context 12 | 13 | Managers make decisions based on their expectations from previous experience,which might not apply in the new and unknown environment of a cloud native system. 14 | 15 | - Long development and release cycles (six months to a year, or even longer) that are typical in the Waterfall development approach result in products that are no longer relevant by the time they reach the customer. 16 | - Software systems and users are complex systems. It’s impossible to predict behavior. 17 | - In hierarchical organizations managers protect their status by knowing everything and deciding everything. 18 | - Technically it is easy to collect data. 19 | - Measuring the wrong things may lead to bad results. 20 | 21 | ## Therefore 22 | 23 | Make product decisions based on data collected from actual users (observability,measure what matters).Data can be collected automatically by embedding the data collection tools into theplatform and all applications before they are released to customers. However, developers need to be careful not to be overly reliant on, or trusting of, user feedback/data.Users often don’t know what they want, especially in regards to radical innovation. 24 | 25 | - Apply the A/B Testing pattern to evaluate different options by exposing them to the real customers. 26 | - Similarly the Learning Loop pattern builds on Data-Driven Decision Making. 27 | - Collect feedback and clicks/business measurements following the release of changes. 28 | 29 | ## Consequently 30 | 31 | The team can quickly make decisions based on objective measurements. 32 | 33 | {:.plusminus} 34 | - {:.plus} Instead of arguing on direction, team can set up experiments and measure. 35 | - {:.minus} It is easier to follow the herd. 36 | - {:.minus} It is not always easy to measure and interpret the right things. 37 | - {:.minus} Sometimes data and users are wrong, and the team needs to trust their instinct and pivot to a radical change. 38 | -------------------------------------------------------------------------------- /_organization-culture/communicate-through-tribes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Communicate Through Tribes 3 | description: Create groups of people who have similar skills but are on different teams to cross-pollinate ideas across the company and provide valuable whole-organization perspective 4 | layout: pattern 5 | --- 6 | 7 | ![Communicate Through Tribes]({{ site.baseurl }}/assets/images/communicating%20through%20tribes.png) 8 | 9 | A company is moving from a hierarchical Waterfall approach to the quickly evolving and complex world of cloud native. In traditional organizations, decision making and knowledge sharing are done according to hierarchy, and managers or lead architects are responsible for knowing everything about their assigned projects. In cloud native,however, engineers are given ownership over microservices and need to make decisions quickly and independently. Delivery processes are being fully automated. 10 | 11 | ## In This Context 12 | 13 | In a changing cloud native world, with ownership for application services divided across teams, managers don’t know enough to provide effective advice, much less make good decisions. At the same time, managers have the illusion of knowledge and control—they don’t know what they don’t know—so the team’s abilities and effectiveness are only as great as its manager’s capability. 14 | 15 | - Cloud native tech is complex and takes time to learn. 16 | - Most delivery decisions in cloud native happen during automated delivery processor very close to it. 17 | - Dependencies between teams and a need to get permission for any change slowdown delivery. 18 | 19 | ## Therefore 20 | 21 | Create domain-specific tribes that operate outside of normal management hierarchy.Use tribes to share specific technical and organizational info and to provide perspective and advice for complex decision making. 22 | 23 | - Members of tribes belong to different teams. 24 | - Meetings are regular and open-ended. 25 | - Tribes play advisory and coordination roles but have no decision-making power. 26 | - All the tribe members are knowledgeable in the tribe’s domain. 27 | 28 | ## Consequently 29 | 30 | The company has groups that cross-cut traditional organizational units. This helps those people who are closest to and most knowledgeable in a particular domain subject identify areas for running experiments and making changes. 31 | 32 | {:.plusminus} 33 | - {:.plus} Tribe members share ideas and advise one another on issues and problems. 34 | - {:.plus} Managers have limited ability to intervene. 35 | -------------------------------------------------------------------------------- /_organization-culture/design-thinking-for-radical-innovation.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Design Thinking for Radical Innovation 3 | description: Whether faced with a radical new idea or a big problem, Design Thinking can be used asa process for first brainstorming a robust list of solutions and then narrowing it down to the best possibilities for actual exploration 4 | layout: pattern 5 | --- 6 | 7 | ![Design Thinking for Radical Innovation]({{ site.baseurl }}/assets/images/design%20thinking%20for%20(R)%20innovation.png) 8 | 9 | We have a big idea or a difficult problem that may change the business. There are possible solutions, but also many uncertainties. 10 | 11 | ## In This Context 12 | 13 | When faced with a problem, people typically spend only the minimum time required to find the first satisfactory solution, even if it’s not the best one or doesn’t involve all stakeholders. This leads to reasonable solutions, but misses the opportunity to find excellent ones. 14 | 15 | - Law of preservation of cognitive energy leads people to choose the first good solution. 16 | - Developers typically are decision makers on tech solutions. 17 | - Devs aren’t trained in business or market forces. 18 | - Elegance and beauty are also relevant for internal systems. 19 | 20 | ## Therefore 21 | 22 | Take the basic first idea and run it through a series of divergent and convergent thinking exercises to rethink the idea’s boundaries and explore alternatives.Ideation/brainstorming is followed by application experiments. In-depth explanation of Design Thinking is beyond the scope of this pattern, but guidelines for running Design Thinking workshops can be found online 10 and many expert facilitators are available to run high-quality workshops. 23 | 24 | - Create 10 to 20 new solutions/problems/ideas based on the first idea, narrow that list to the two to three best ones. Then expand and iterate these two to three bestones into 10 to 20 new possible variations, and then again choose two to three ofthe most promising to run longer experiments and choose to implement. 25 | - Hold regular Design Thinking workshops. 26 | - Use the workshops to refine big ideas/problems. 27 | - Invite major stakeholders. 28 | - Facilitate collaboration to help excellent solutions emerge. 29 | 30 | ## Consequently 31 | 32 | Ideas are thoroughly explored. Cost of initial exploration is still low, as it requires little to no actual development (No Regret Moves). 33 | 34 | {:.plusminus} 35 | - {:.minus} Too many people involved slows down the decision-making process. 36 | -------------------------------------------------------------------------------- /_organization-culture/gradual-onboarding.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Gradual Onboarding 3 | description: One to three months before the new platform goes live, begin training a couple of teams at a time with a pause between each cohort to incorporate feedback and improve the process/materials 4 | layout: pattern 5 | --- 6 | 7 | ![Gradual Onboarding]({{ site.baseurl }}/assets/images/gradual%20onboarding.png) 8 | 9 | There is pressure from the top, the executives and board, to start using the cloud native platform as soon as possible and pressure from below, from the development teams, to move to cool technology. The company spent a lot of time and money building the new system, and everyone is eager to reap the rewards. Developers want to learn and use new technology. 10 | 11 | ## In This Context 12 | 13 | Onboarding too many teams at once will stress the Core Team and reduce its ability to continue improving the platform. Educating people too early, however, willcreate anxiety in the teams and desire to start as soon as possible (and frustration if there is a long wait before the new system is available). 14 | 15 | - A team that releases a tool on a large scale with low quality will struggle to improve it 16 | - People have little patience and are eager to apply recent learning. 17 | - If you learn something new, you need to start using that knowledge soon or risk losing it. 18 | - Good people may go to other companies to have a chance to work with the new and exciting technologies. 19 | 20 | ## Therefore 21 | 22 | Start small organizational changes early in the cloud native transformation. Prepare materials to onboard other teams and execute it slowly when teams are ready.Continue onboarding the rest of the organization gradually over a period of 3 to 12 months. 23 | 24 | - Start educating teams one to three months before onboarding. 25 | - Prepare Developer Starter Packs and all relevant educational materials to simplify the onboarding. 26 | - Onboard two to five teams at a time. Take breaks in between to use their feedback to improve the platform. 27 | - Continuously improve the platform and the onboarding materials based on the feedback from the recently onboarded teams. 28 | 29 | ## Consequently 30 | 31 | The Core Team can support teams as they onboard and improve the process as they go. The first few teams onboarded to the platform can help educate and support the teams onboarded later. 32 | 33 | {:.plusminus} 34 | - {:.minus} Some teams may not join for one to three years. 35 | - {:.minus} Slower perception of scale. 36 | -------------------------------------------------------------------------------- /_operations/metrics-over-logs.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Metrics over Logs 3 | description: Use metrics as the primary data source to monitor application and system health 4 | layout: pattern 5 | --- 6 | 7 | ![Metrics over Logs]({{ site.baseurl }}/assets/images/metrics.png) 8 | 9 | A team is moving from a legacy style monolithic system to a cloud native platform. Traditionally most information from applications gets pushed into logs. Cloud Native systems offer a better approach to gaining insight into our applications. 10 | 11 | ## In This Context 12 | 13 | When building applications, traditionally we send all relevant information out as logs. Monitoring or metrics were mainly used for the health of our physical infrastructure. Applying this pattern to a modern distributed system composed of dozens of components results in a petabytes of mostly useless data. 14 | 15 | - The lack of well defined structure makes parsing logs nearly impossible across multiple services. 16 | - 99% of log data is never used, or seen and serves only to run up cloud costs. 17 | - Logs are not a viable set of data on which we can build alerts or notifications. 18 | - There is no clear view on the actual health of our system. 19 | - Metrics based on a single instance (e.g. application container or cluster node) are meaningless. 20 | 21 | ## Therefore 22 | 23 | The purpose of each type of data, logs and metrics, must first be well established. Logs should be used as a secondary method for gaining further knowledge on a specific incident (i.e. debugging). Metrics are a way to get a holistic view on your applications and system as a whole. 24 | 25 | - Data sent to logs should be minimized as much as possible. 26 | - Relevant global metrics must be defined. 27 | - For each service, the owner must define metrics which are relevant and make them available to the monitoring system. 28 | - Metrics should comply with the Open Metrics () standard. 29 | 30 | ## Consequently 31 | 32 | The team can get a clear, centralized view on the overall health of the system and its components. 33 | 34 | {:.plusminus} 35 | - {:.plus} Log data is greatly simplified and reduced (saving cost). 36 | - {:.plus} When logs are needed (to debug an issue) finding the relevant logs becomes much easier. 37 | - {:.plus} An accurate view on the health of your system is available. 38 | - {:.plus} The standardized metrics can easily be shipped to a variety of monitoring platforms and tools. 39 | - {:.plus} Comprehensive alerts can be built on top of the available metrics. 40 | 41 | -------------------------------------------------------------------------------- /_organization-culture/blameless-inquiry.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Blameless Inquiry 3 | description: When a problem occurs, focusing on the event instead of the people involved allows them to learn from mistakes without fear of punishment 4 | layout: pattern 5 | --- 6 | 7 | ![Blameless Inquiry]({{ site.baseurl }}/assets/images/blameless%20inquiry.png) 8 | 9 | A company is proficiently delivering existing products or services while investing some resources into continued innovation. There is a lot of uncertainty, and experimentation is required for figuring out the tech and exploring new business opportunities. Naturally, many of the experiments lead to dead ends. 10 | 11 | ## In This Context 12 | 13 | When no inquiry is done after a problem occurs or an experiment fails, the team doesn’t improve and is likely to keep making similar mistakes. In many organizations,fault-seeking occurs, and blame gets assigned to anyone involved with a problem. This leads to mediocre performance, since most innovative actions carry significant risk. 14 | 15 | - Once punished for failure people tend to avoid risks. 16 | - Waterfall organizations tend to punish teams or individuals associated with problematic events to ensure stability; novelty is discouraged. 17 | - There is no innovation without risk. 18 | 19 | ## Therefore 20 | 21 | Understand what went wrong by focusing on the problem instead of the peopleinvolved.Talk about what went wrong and why, and how to avoid it in the future. Don’t punish people for mistakes—encourage them to learn from the experience instead. This creates the psychological safety required for taking risks. 22 | 23 | - Gather everyone involved and review what happened. 24 | - Share the results with the rest of the team. 25 | - Find possible solutions for avoiding similar problems in the future. 26 | - Focus on the problem, not the people: don’t ask who did what and never assign blame. 27 | - If some mistakes occur repeatedly, find out who is involved and introduce personal commitment/responsibility. 28 | 29 | ## Consequently 30 | 31 | People have the autonomy and the confidence to try and fail, and try again. 32 | 33 | {:.plusminus} 34 | - {:.plus} Teams are always improving by learning how to find and avoid repeated mistakes. 35 | - {:.plus} Progress happens faster since people don’t waste time and effort trying to find a solution that is “guaranteed to work” before they even risk trying it. 36 | - {:.minus} If there are no consequences for failure, some people may fail due to not taking personal responsibility for solving problems as they arise. 37 | -------------------------------------------------------------------------------- /_operations/cicd-as-platform.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: CI/CD as Platform 3 | description: The CI/CD system is treated as a platform on top of the cloud platform. 4 | layout: pattern 5 | --- 6 | 7 | ![CI/CD as Platform]({{ site.baseurl }}/assets/images/cicd.png) 8 | 9 | An Enterprise company is developing Cloud Native CI/CD services during a transformation or 10 | cloud migration. CI/CD services include building of container images, code quality checks, 11 | security scans and deployment of artifacts to environments. CI/CD plays a significant 12 | part in compliance requirements and making sure production systems are secure. 13 | 14 | 15 | ## In This Context 16 | 17 | The complexity of software delivery in an enterprise company can easily reach a level when 18 | a dedicated team would have to be responsible for its maintenance. 19 | 20 | CI/CD services on an Enterprise scale are difficult to implement. Taking into account 21 | requirements for auditing, compliance and team flexibility will lead to a system 22 | which is customized to a high degree. Often the responsibility for the these services 23 | end up with the Platform Team, which is managing infrastructure. While CI/CD is related 24 | to the infrastructure platform, it has it's own goals and a different domain (in DDD terms). 25 | 26 | ## Therefore 27 | 28 | Create a dedicated product team, which will build and manage CI/CD services. This team will 29 | be a consumer of the infrastructure platform and a service provider towards development 30 | teams. The CI/CD Platform Team should treat CI/CD services as a product offered to all 31 | development teams. 32 | 33 | This means feature requests should be phrased in a way that is useful to 34 | all users of the platform. All platform services should be self-service, CI/CD Platform Team 35 | members should only interact with application developers in limited ways (e.g. support) so 36 | they can focus on building functionality. Thus the team is an internal product team, not an 37 | enabler team. 38 | 39 | ## Consequently 40 | 41 | {:.plusminus} 42 | - {:.plus} CI/CD services are treated as first class citizens in the larger Cloud Native Platform 43 | - {:.plus} Application teams can consume CI/CD services without waiting for actions from another team 44 | - {:.plus} Specialist knowledge can be more easily built up and used in a team with fewer reponsibilities 45 | - {:.minus} Development teams have to wait until features get prioritized in a product backlog. 46 | - {:.minus} CI/CD Platform Team can't solve Infrastructure Platform issues affecting them. 47 | 48 | -------------------------------------------------------------------------------- /_sass/components/_content.scss: -------------------------------------------------------------------------------- 1 | .content { 2 | align-items: center; 3 | font-size: 22px; 4 | line-height: 30px; 5 | justify-content: space-between; 6 | margin-left: auto; 7 | margin-right: auto; 8 | max-width: 940px; 9 | padding: 80px 0px; 10 | text-align: justify; 11 | 12 | h1 { 13 | font-size: 32px; 14 | font-weight: bold; 15 | line-height: 36px; 16 | margin: 20px 0px 30px; 17 | text-transform: uppercase; 18 | } 19 | 20 | table { 21 | width: 100%; 22 | 23 | td { 24 | float: none; 25 | width: 50%; 26 | 27 | a { 28 | color: #000; 29 | margin: 20px; 30 | vertical-align: middle; 31 | 32 | &:hover { 33 | color: #000; 34 | text-decoration: none; 35 | } 36 | } 37 | } 38 | 39 | @media all and (max-width: 700px) { 40 | td { 41 | float: left; 42 | width: 100%; 43 | } 44 | } 45 | } 46 | 47 | ul.plusminus { 48 | list-style-type: none; 49 | margin: 0; 50 | padding: 0; 51 | 52 | li.minus { 53 | padding: 0px 0px 0px 40px; 54 | position: relative; 55 | 56 | &:before { 57 | content: "-"; 58 | font-weight: 800; 59 | left: 16px; 60 | position: absolute; 61 | } 62 | } 63 | 64 | li.plus { 65 | padding: 0px 0px 0px 40px; 66 | position: relative; 67 | 68 | &:before { 69 | content: "+"; 70 | font-weight: 800; 71 | left: 16px; 72 | position: absolute; 73 | } 74 | } 75 | } 76 | } 77 | 78 | .book-section { 79 | background-color: #000; 80 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 81 | background-size: cover; 82 | color: #fff; 83 | font-weight: 600; 84 | 85 | a { 86 | color: #fff; 87 | text-decoration: underline; 88 | 89 | &:hover { 90 | color: #fff; 91 | } 92 | } 93 | 94 | div { 95 | background-color: transparent; 96 | background-image: none; 97 | } 98 | } 99 | 100 | .cta-section { 101 | text-align: center; 102 | 103 | strong { 104 | text-transform: uppercase; 105 | } 106 | } 107 | 108 | .patterns-section { 109 | a { 110 | color: #000; 111 | font-size: 32px; 112 | font-weight: 600; 113 | line-height: 36px; 114 | margin: 30px 0px 0px; 115 | 116 | &:hover { 117 | color: #000; 118 | text-decoration: none; 119 | } 120 | } 121 | } 122 | -------------------------------------------------------------------------------- /_development-design/no-long-tests-in-ci-cd.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: No Long Tests in CI/CD 3 | description: Execute non-critical long-running tests in the background so they don’t block delivery to production 4 | layout: pattern 5 | --- 6 | 7 | ![No Long Tests in CI/CD]({{ site.baseurl }}/assets/images/No%20long%20tests%20in%20CI-CD.png) 8 | 9 | CI/CD is in place, and most tests are automated. Some are taking hours or even longer, and others require manual execution. 10 | 11 | ## In This Context 12 | 13 | Delivering changes quickly is a major goal of the cloud native approach to delivering software.Long-running performance tests, reliability tests, and manual and other types of full-system tests can take too long and delay delivery for hours—rendering CI/CD less valuable. Instead of dozens or even hundreds of times a day, delivery frequency gets reduced to just a few times per day. Similarly, fixing a bug or problem goes from taking a few minutes to instead requiring several hours. 14 | 15 | - Manual intervention can create very long delays. 16 | - Frequent integrations require a fast build/test cycle. 17 | 18 | ## Therefore 19 | 20 | Run your fastest tests earliest in the process. Schedule all tests that are manual, or which take longer than a few minutes to run, outside of the normal delivery process.If you have a test that is critical for functionality, however, it should be run asa blocking test.Mitigating risk is an equally important cloud native goal, which is why automated testing is a core tenet of the architecture. These two things need not conflict. There are strategies that allow adequate testing while enabling teams to still release quickly and constantly. Short-running tests can be incorporated into the pre-deployment process, while long-running tests can be executed in the background without blocking delivery to production. 21 | 22 | - Run tests periodically post-delivery, and if a problem is found, either roll back the change or fix the problem and roll forward in a new release. 23 | - Run long tests in parallel. 24 | - Split the test automation into smaller test segments. 25 | 26 | ## Consequently 27 | 28 | Testing does not delay or disturb delivery. Quality of the products is kept high by the right balance of ever-changing tests. 29 | 30 | {:.plusminus} 31 | - {:.plus} Non-blocking long-running tests reveal problems without slowing velocity. 32 | - {:.plus} Release is quick and easy.+ Devs can deliver many times a day. 33 | - {:.minus} Some issues can carry through to production. 34 | - {:.minus} Requires strong roll back/roll forward protocol and procedures in place. 35 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/options-and-hedges.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Options and Hedges 3 | description: Research has created deeper understanding, and a few potentially promising transformation paths have begun to emerge. Continue reducing the risk by focusing on the most promising options and developing them further 4 | layout: pattern 5 | --- 6 | 7 | ![Options and Hedges]({{ site.baseurl }}/assets/images/Options%20_%20Hedges.png) 8 | 9 | You have achieved moderate certainty by running a series of small experiments,research projects, and trainings, but the team is not yet confident enough to make major decisions about the transformation. 10 | 11 | ## In This Context 12 | 13 | Your research has given you a better understanding of what is going on, but major decisions are still not obvious. Commitment to a large solution at this point still carries serious high risk of choosing the wrong solution, while running additional tiny experiments that uncover no new information is just a waste of time. 14 | 15 | - Pressure is rising to make commitments. 16 | - Too easy to keep running experiments forever. 17 | - There will always be some uncertainty, no matter how much research you do. 18 | 19 | ## Therefore 20 | 21 | Make small tactical decisions aimed at creating and understanding a new path forward. They can be rolled back or forward, ramped up or down, and will at least eliminate some options while you create new plans. The goal is to validate the results of any successful experiments performed so far. 22 | 23 | - Do mid-size proof-of-concept projects that take a few weeks to a couple of months. 24 | - Stay aware of biases like the IKEA effect and sunk-cost fallacy that could lead to sticking with a solution even when it’s not really working. 25 | - No commitments yet! Maintaining the ability to change direction reasonably easily is still important here. 26 | - Take a vendor-neutral approach: companies need the best tools and techniques for their cloud native platform, and these are not necessarily the ones offered in bundled solutions. 27 | 28 | ## Consequently 29 | 30 | You have uncovered the majority of the important information required and are reasonably certain where you are going next. 31 | 32 | {:.plusminus} 33 | - {:.plus} Risk declines because, as you experiment, you eliminate things that don’t work and reveal the ones that do. 34 | - {:.plus} Next steps come into stark relief. The results of all these little experiments actually shape the architecture of the new system. 35 | - {:.plus} You are ready to take the next big steps (Big Bet) because you have gained knowledge and experience. 36 | -------------------------------------------------------------------------------- /_operations/ephemeral-environments.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ephemeral Environments 3 | description: Leverage automation to create ephemeral environments on demand 4 | layout: pattern 5 | --- 6 | 7 | ![Ephemeral Environments]({{ site.baseurl }}/assets/images/ephemeral_environments.png) 8 | 9 | A team running applications on modern cloud native platform (such as Kubernetes) often requires a variety of environments. Getting a production like environment running on a developers laptop is often not possible. The benefit of automated infrastructure means the cost of creating these environments is cheap. Running and managing them not so much. 10 | 11 | ## In This Context 12 | 13 | Container technology has taken us a long way to resolving the 'it works on my machine' problem. However, in a microservice environment, the number of dependencies for truly validating the functionality of service can still make this a big challenge. 14 | 15 | - Mimicking production on a developer's laptop is often not feasible. 16 | - Creating clusters and environments becomes easy with automation, but the cost, both monetary as well as resources to manage all the clusters can grow quickly. 17 | 18 | ## Therefore 19 | 20 | By leveraging automation, and a modern cloud platform, environment's can be created on demand, and removed once they are no longer needed. There's no reason why we need to keep the old ways of having permanent (testing, qa, staging) environments. 21 | 22 | - Add stages to the build pipeline to create a new environment for each deployment. 23 | - Validation tests are automated against the newly created environment. 24 | - A temporary URL can be made availble for any manual validation which needs to be done. 25 | - The environments shoud be automatically removed, either after completion of the pipeline, or after a set period of time. 26 | 27 | ## Consequently 28 | 29 | {:.plusminus} 30 | - {:.plus} In the spirit of immutable infrastructure, having short lived on demand environments reduces the risk of configuration drift with long lived environments. 31 | - {:.plus} Infrastrucutre automation gets frequently validated and optimisation of the automation becomes essential. 32 | - {:.plus} The confidence of the build pipeline increases as all changes are validated against production like environments. 33 | - {:.plus} Cloud costs are greatly reduced as we only run the environments when needed. 34 | - {:.minus} If environments are not automatically removed, this can have the opposite effect on your cloud costs. 35 | - {:.minus} When environments take too long to create, this can drastically slow down build pipelines. 36 | 37 | -------------------------------------------------------------------------------- /_infrastructure-cloud/self-service.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Self Service 3 | description: In cloud native everyone can do their own provisioning and deployment with no handoffs between teams 4 | layout: pattern 5 | --- 6 | 7 | ![Self Service]({{ site.baseurl }}/assets/images/Self%20service.png) 8 | 9 | The company is moving from Waterfall/Agile and, within a structure of separate operations and development teams, is aiming to set up microservices, CD, and public(or private) cloud. Teams are running many experiments and PoCs and aiming to reduce the cost of experimentation. 10 | 11 | ## In This Context 12 | 13 | In traditional organizations, provisioning hardware or doing maintenance work requires filling out a form, sending it to Ops, and waiting for them to do it on your behalf. Each handover creates a delay of hours, days, even weeks, and this slows down the entire system. This process also discourages frequent releases from developers to production, and without that there is no Continuous Delivery (CD),no learning loop from delivering to customers and receiving feedback. 14 | 15 | - Anything manual is, by definition, too slow for cloud native. 16 | - People will do more of something if they can do it themselves. 17 | - Premature optimization—automating the wrong thing—can be particularly bad in this context. 18 | 19 | ## Therefore 20 | 21 | Across the company, everything related to software development should be self service:everyone should be able to provision infrastructure or deploy their applications on their own without handoff to another team.Self-Service is the requirement—Automate Everything is the way you achieve that. 22 | 23 | - Create full automation around the platform. All manual or semi-manual processes must be fully automated. 24 | - Create UIs and APIs so people can include this in their automation. 25 | - Grant access to all developers (within reasonable security limits). 26 | - Start during the MVP stage: Prerequisite is basically having the entire cloud native toolset. 27 | 28 | ## Consequently 29 | 30 | Whenever anyone needs something done, they can do it on their own without handing off to Ops. 31 | 32 | {:.plusminus} 33 | - {:.plus} Reduced cost of experimentation because there is less waiting for results. 34 | - {:.plus} Reduced dependencies. 35 | - {:.minus} Functional self-service needs a much higher-quality interface, which is a much higher cost. 36 | - {:.minus} The system is automated to be bulletproof against wrong behavior by nonexperts using it, which is valuable but also has cost. If you have experts working on infra, they don’t need foolproof systems—but most people aren’t experts. 37 | -------------------------------------------------------------------------------- /_development-design/open-source-internal-projects.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Open Source Internal Projects 3 | description: Use open source solutions for any software need that is not directly related to the company’s core business value 4 | layout: pattern 5 | --- 6 | 7 | ![Open Source Internal Projects]({{ site.baseurl }}/assets/images/Open%20source%20internal%20projects.png) 8 | 9 | The company is building a lot of software, but most of it covers generic needs—only a minor percentage is related to delivering the actual core business products/services. 10 | 11 | ## In This Context 12 | 13 | When a project is strictly internal, there is a tendency to cut corners to save time.Meanwhile, the open source community is constantly coming up with new tools to solve business use cases in the cloud native world.Internal projects that are not in a company’s core business area take time away from that essential work. Furthermore, they rarely get the priority to be built at the highest quality, and always get lowest priority for maintenance. Over time they become outdated and quality suffers, while innovation is limited or lost. Meanwhile, the rest of the market goes full-speed ahead. 14 | 15 | - When something is invisible to the public, there are few incentives to make it nice. 16 | - There are many other teams outside of the company having similar challenges. 17 | - Good devs are attracted to interesting tech. 18 | - Internal projects rarely get budget for cosmetic or procedural improvements. 19 | - Many major cloud native tools are open source projects (Kubernetes!). 20 | 21 | ## Therefore 22 | 23 | All software that does not address company core business (“secret sauce”) can be open sourced from the start. 24 | 25 | - Use open source software (OSS) whenever possible. 26 | - New projects should be OSS by default. 27 | - Use OSS governance and development practices even for internal projects. 28 | - Always give back by contributing to the open source products you choose. 29 | - Promote and market OSS projects. 30 | 31 | ## Consequently 32 | 33 | If there is a gap in functionality, instead of building a new solution internally, contribute to existing open source projects and contribute back to them. Alternatively,create your own open source solution and invite others to use, contribute to,and improve it. 34 | 35 | {:.plusminus} 36 | - {:.plus} Code quality is higher, as the project is more visible. 37 | - {:.plus} Contributions from other people help the project continually improve. 38 | - {:.plus} Contributing to OSS boosts the company’s tech reputation. 39 | - {:.minus} Lose some control. 40 | - {:.minus} Competitors can use it too. 41 | -------------------------------------------------------------------------------- /_organization-culture/ongoing-education.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Ongoing Education 3 | description: Continuously introduce new ways and improve existing ones to help teams continually develop their cloud native knowledge and skills 4 | layout: pattern 5 | --- 6 | 7 | ![Ongoing Education]({{ site.baseurl }}/assets/images/ongoing%20education.png) 8 | 9 | The company is moving to cloud native, and some teams have never worked with cloud native technology or processes. In their previous environment, knowledge and learning were reasonably stable and linear (learn a bit and exploit the knowledge a lot).Other teams are already deep into building the cloud native platform or microservices and so have gained basic cloud native knowledge, but still are not advanced enough to support the entire transformation. 10 | 11 | ## In This Context 12 | 13 | People are joining the organization’s cloud native initiative without fully understanding the possibilities it offers or the wide variety of solutions available. New technology is introduced all the time that renders current tools and techniques out of date. When this happens, productivity suffers, and change slows down. 14 | 15 | - Only some people are motivated to learn on their own. 16 | - People learn better in groups. 17 | - Formal education is more effective after some initial exposure to/experience with new information. 18 | - Most people need to learn something a few times before they fully understand it. 19 | - The cloud native ecosystem is changing fast. 20 | 21 | ## Therefore 22 | 23 | Build and continuously run an education program about cloud native for everyone in the company, from basic education for newly onboarded or new joiners to continuous and more advanced trainings for more experienced engineers. 24 | 25 | - Onboarding bootcamps 26 | - Hackathons 27 | - Periodic knowledge updates 28 | - Management trainings 29 | - Online self-learning opportunities 30 | - Books, blog posts, and other reading 31 | - On-the-job learning by pair programming, whiteboarding, etc. 32 | 33 | ## Consequently 34 | 35 | Team knowledge is constantly refreshed and updated. 36 | 37 | {:.plusminus} 38 | - {:.plus} Easy ways to roll out new information. 39 | - {:.plus} A lot of inspiration arises for trying out changes. 40 | - {:.plus} Developers are better able to adapt to technology shifts. 41 | - {:.plus} Technology changes, which are inevitable, will be minimally disruptive since developers are better able to adapt to shifts in tech. 42 | - {:.plus} By disseminating best practices and successful ways of using technology, you can replicate success and avoid missteps. 43 | - {:.minus} There is cost related to frequent education. 44 | -------------------------------------------------------------------------------- /_infrastructure-cloud/automated-infrastructure.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Automated Infrastructure 3 | description: The absolute majority of operational tasks need to be automated. Automation reduces interteam dependencies, which allows faster experimentation and leads in turn to faster development 4 | layout: pattern 5 | --- 6 | 7 | ![Automated Infrastructure]({{ site.baseurl }}/assets/images/automated%20infrastructure.png) 8 | 9 | A company is moving to cloud native and adopting cloud native patterns such as Microservices Architecture, Continuous Delivery, and others. Teams are independent and require fast support services from the Platform Team. Most of the operational tasks are performed on demand by the Ops team. 10 | 11 | ## In This Context 12 | 13 | Manual or semi-automatic provisioning of infrastructure leads to dependencies among the teams and to long waiting times for results, hindering experimentation and slowing development. 14 | 15 | - Traditional operational teams don’t have sufficient levels of automation and, dueto high workload, no time to learn new technologies. 16 | - Public clouds provide full automation of infrastructure resources. 17 | - Manual requests and handover between development and operations teams is very slow. 18 | - Number of operations engineers in manual systems must scale up proportionally to growth in infrastructure demands. 19 | - Experimentation and research take longer and require more resources due to involvement of an already-busy operations department. 20 | 21 | ## Therefore 22 | 23 | Dedicate at least 50% of the Ops team’s time to automating the operational tasks,and eliminate all manual infrastructure provisioning and maintenance tasks.Any manual work that is required in between the changes committed by the developerand the delivery to production will significantly reduce the speed of delivery and introduce interteam dependencies. 24 | 25 | - Treat infrastructure automation scripts with equal importance as the rest of the company codebase. 26 | - Automate, fully and completely: compute, storage, networking, and other resources;patching and upgrading of operating systems; and deployment and maintenance of systems running on top of the infrastructure. 27 | 28 | ## Consequently 29 | 30 | Developers spend less time waiting for infrastructure resources and can conduct quick experiments and scale running systems rapidly and easily. 31 | 32 | {:.plusminus} 33 | - {:.plus} Ops team spending significantly less time on repetitive support tasks and investing more time and resources in ongoing improvement of the system. 34 | - {:.plus} Full automation will allow the provisioning of exponentially more resources per member of operational staff. 35 | -------------------------------------------------------------------------------- /_organization-culture/exploratory-experiments.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Exploratory Experiments 3 | description: When dealing with a complex problem with no obvious available solution, run a series of small experiments to evaluate the possible alternatives and learn by doing 4 | layout: pattern 5 | --- 6 | 7 | ![Exploratory Experiments]({{ site.baseurl }}/assets/images/design%20thinking%20for%20(R)%20innovation.png) 8 | 9 | The challenge is new and complex, and the team can’t solve it by using its existing knowledge or through simple research (i.e., you can’t Google it). There is not enough information to make the next step, much less a proper decision. 10 | 11 | ## In This Context 12 | 13 | Committing too early to a solution you don’t yet fully understand. Teams are likely to choose a known solution that is not a good fit for the problem, because they understand it; undertake a lengthy analysis of the solution that leads nowhere(analysis paralysis); or jump on the first available solution (availability bias). 14 | 15 | - In Waterfall all questions need to be answered before actions are taken. 16 | - People learn best by doing. 17 | - Difficult problems are better solved by a team. 18 | 19 | ## Therefore 20 | 21 | Explore the problem space. Mitigate the risk by delaying critical decisions long enough to run a series of small scientific-style experiments to uncover missing information and evaluate alternatives.Each experiment should have a hypothesis that can be proved or disproved by the experiment. When a hypothesis is disproved, the experiment itself can still be called a success. It is critical to avoid assigning blame or punishing those involved in the experiment in cases where the results are not satisfactory. 22 | 23 | - Identify one problem/idea and choose two to five small—taking a few hours to afew days—experiments to test it. 24 | - Form a hypothesis to query What is my problem in the first place, does this solve it,what is the cost, and can we afford it? 25 | - Identify and compare possible alternative solutions. 26 | - Establish clear and measurable criteria for success or failure. Collect data and evaluate it. 27 | 28 | ## Consequently 29 | 30 | The team is granted time and given a process for experimenting with solutions when it encounters a complex problem. 31 | 32 | {:.plusminus} 33 | - {:.plus} Teams learn by doing this, which helps them in future decisions and work. 34 | - {:.plus} By showing a small, quick success with an experiment, you are able to make a first small and easy step in a new direction. 35 | - {:.minus} When experiments are cheap and easy enough to run, it can be hard to determine when it is time to stop experimenting and make a decision/move forward. 36 | -------------------------------------------------------------------------------- /_development-design/a-b-testing.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: A/B Testing 3 | description: Comparing multiple versions of something (a feature, new functionality, UI, etc.) underreal customer use conditions quickly gives useful data about which performs better 4 | layout: pattern 5 | --- 6 | 7 | ![A/B Testing]({{ site.baseurl }}/assets/images/a-b%20testing.png) 8 | 9 | A company has a working cloud native infrastructure in place and is aiming to deliver a lot of useful functionality to its customers. Teams are proficient, and all the tech and processes are in place. 10 | 11 | ## In This Context 12 | 13 | There is no practical way to predict how customers will respond to changes. In the absence of actual customer usage data, design and implementation decisions must be based on guesswork and intuition. Since our intuition is not perfect and full of biases, we may not get the best possible results. 14 | 15 | - People don’t always know what they need/want. 16 | - Delivering fast without adjusting the product based on measurement and feedback will change nothing. 17 | - It’s impossible to make logical decisions in an unknown environment. 18 | - There are unlimited variations and combinations of possible solutions. 19 | 20 | ## Therefore 21 | 22 | Prepare multiple versions of a solution to a challenge/problem and present them to randomized small portions of the client base. Measure the customer response in terms of value for them, and based on that choose the solution. 23 | 24 | - Famous Google example of testing 41 shades of blue for its toolbar1 to find which inspired the most consumer clicks—because, for Google, clicks equal revenue. 25 | - The Obama campaign raised more money by using A/B testing to choose the most effective messaging. 26 | - Need to provide business people with the opportunity to run the A/B test experiments themselves, and an accessible way for them to do so. 27 | 28 | ## Consequently 29 | 30 | You now have an easy way to test assumptions live in a real-world environment.Instead of making guesses or assumptions regarding which of two ideas, implementation strategies, etc., is better, a team can quickly put together a simple prototype with two or more versions and release them to small subsets of real customers. Based on customer response, the team can choose the more appropriate/preferred solution.This way many options could be tested while costs are ultimately saved because onlythe best option is ever fully implemented. 31 | 32 | {:.plusminus} 33 | - {:.plus} Customers see response to their needs. 34 | - {:.plus} If something doesn’t work, you can easily roll back to previous version. 35 | - {:.minus} Human insight might be sidelined when user response data is followed blindly. 36 | -------------------------------------------------------------------------------- /_infrastructure-cloud/continuous-delivery.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Continuous Delivery 3 | description: Keeping a short build/test/deliver cycle means code is always ready for production and features can be immediately released to customers—and their feedback quickly returned to developers 4 | layout: pattern 5 | --- 6 | 7 | ![Continuous Delivery]({{ site.baseurl }}/assets/images/continuous%20delivery.png) 8 | 9 | Teams are doing Continuous Integration, so each change is automatically built and tested separately in a very short time. Developers commit changes at least once a day.Teams are building distributed systems using microservices architecture. 10 | 11 | ## In This Context 12 | 13 | A full quality test of a distributed system can be done only when the entire system is fully deployed and used. Teams try to reduce complexity and increase quality through infrequent and coordinated multiple-team deployments to the test environment,and then handing off to the operations team for more extensive testing and, finally, delivery.Large-scale deployments at long intervals are usually difficult and time consuming,so teams tend to minimize their number. This leads to painful integrations between services, reduced independence of teams, slower time to market, and—eventually—lower quality and higher costs for building the product or service. 14 | 15 | - There is more incentive to automate an operation if it happens more frequently(if something is painful do it more often). 16 | - Some issues cannot be caught by automation. 17 | - People gain trust in an action when it’s executed frequently and rarely fails. 18 | - People lose trust quickly if quality is low or reporting unreliable. 19 | - Small changes delivered by the teams themselves are easy to fix or revert. 20 | - Recent changes are still fresh in developers’ minds. 21 | 22 | ## Therefore 23 | 24 | Deliver every change to a production-like environment where all the services are delivered continuously and independently.Reduce the pain by using full automation coupled with increased speed and frequency of releases.- No manual handovers on the way to deployment. 25 | 26 | - Full automation is now in place. 27 | - Test automation is now in place. 28 | - Products are always in a releasable state. 29 | - Experiments are more effective, as getting feedback from real customers is fast and painless. 30 | 31 | ## Consequently 32 | 33 | The business can release to customers anytime. 34 | 35 | {:.plusminus} 36 | - {:.plus} A feature can be tested very quickly with customers. 37 | - {:.minus} Some failures will sneak in through automation. 38 | - {:.minus} Very high level of automation is critical; any manual steps slow the process and introduce problems. 39 | -------------------------------------------------------------------------------- /_organization-culture/proof-of-concept-poc.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Proof of Concept (POC) 3 | description: Before fully committing to a solution that can significantly affect the future, build as mall prototype to demonstrate viability and gain a better understanding 4 | layout: pattern 5 | --- 6 | 7 | ![Proof of Concept (POC)]({{ site.baseurl }}/assets/images/proof%20of%20concept.png) 8 | 9 | You have run experiments and identified a solution path that you think could be the right one, but there are still some big unknowns. You are at a decision point: adopt this solution, or not? 10 | 11 | ## In This Context 12 | 13 | Once some initial experiments have uncovered a likely transformation path, it is time to test it. Committing to it right now could, if it is wrong, cause large problems and expense as the initiative continues. 14 | 15 | You simply don’t know enough to make a large commitment at this point. Any full commitment right now carries massive risk because switching to an alternative later will be very difficult. Adopting a solution you don’t fully understand too early in the process compounds the risk, because you will continue to build further functionality on top of this solution. 16 | 17 | - Hands-on work, rather than promises or explanations, is better for demonstrating value to skeptics. 18 | - Changing early decisions is costly in the later stages of a migration project. 19 | 20 | ## Therefore 21 | 22 | Build a basic functional prototype to demonstrate the viability of a solution.Define the questions that need answers before starting the PoC and stop the workonce the questions are answered. 23 | 24 | - This should take a few days to a few weeks. 25 | - Build the most primitive version you can get away with. Be ready to throw it away when you are finished. (This doesn’t that mean you must throw it away, but often when initial quality is intentionally low, it’s cheaper and easier to just scrap it and rebuild from scratch). 26 | - Only work on hard issues related to the specific needs of the current project, and stop when the solution is clear. 27 | - Try to demo something functional so you can collect business-related information regarding how this solution will impact future development. 28 | 29 | ## Consequently 30 | 31 | Risk is reduced for the overall project in the early stages of the migration. Criticalknowledge and experience are gained during the experimentation process. 32 | 33 | {:.plusminus} 34 | - {:.plus} You have gained the knowledge and proved the solution works, and now understand how it fits into the overall project. 35 | - {:.plus} You now have reasonable confidence that this is the correct decision. 36 | - {:.minus} Running PoCs carries cost. Every time you do it, you pay for it. 37 | -------------------------------------------------------------------------------- /_sass/components/_patterns.scss: -------------------------------------------------------------------------------- 1 | $development-design-color: #e16b63; 2 | $infrastructure-cloud-color: #7a60a3; 3 | $organization-culture-color: #6eb2df; 4 | $strategy-risk-reduction-color: #80bfb1; 5 | $technical-color: #E1CC63; 6 | 7 | .button { 8 | &.development-design { 9 | background-color: #{$development-design-color}; 10 | } 11 | 12 | &.infrastructure-cloud { 13 | background-color: #{$infrastructure-cloud-color}; 14 | } 15 | 16 | &.organization-culture { 17 | background-color: #{$organization-culture-color}; 18 | } 19 | 20 | &.strategy-risk-reduction { 21 | background-color: #{$strategy-risk-reduction-color}; 22 | } 23 | 24 | &.technical { 25 | background-color: #{$technical-color}; 26 | } 27 | } 28 | 29 | .dropdown-menu, 30 | .header-strip { 31 | &.patterns-library { 32 | background-color: #000; 33 | color: #fff; 34 | } 35 | 36 | &.development-design { 37 | background-color: #{$development-design-color}; 38 | color: #000; 39 | } 40 | 41 | &.infrastructure-cloud { 42 | background-color: #{$infrastructure-cloud-color}; 43 | color: #000; 44 | } 45 | 46 | &.organization-culture { 47 | background-color: #{$organization-culture-color}; 48 | color: #000; 49 | } 50 | 51 | &.strategy-risk-reduction { 52 | background-color: #{$strategy-risk-reduction-color}; 53 | color: #000; 54 | } 55 | 56 | &.technical { 57 | background-color: #{$technical-color}; 58 | color: #000; 59 | } 60 | } 61 | 62 | .title-strip { 63 | &.patterns-library { 64 | background-color: #000; 65 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 66 | color: #fff; 67 | } 68 | 69 | &.development-design { 70 | background-color: #{$development-design-color}; 71 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 72 | color: #fff; 73 | } 74 | 75 | &.infrastructure-cloud { 76 | background-color: #{$infrastructure-cloud-color}; 77 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 78 | color: #fff; 79 | } 80 | 81 | &.organization-culture { 82 | background-color: #{$organization-culture-color}; 83 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 84 | color: #fff; 85 | } 86 | 87 | &.strategy-risk-reduction { 88 | background-color: #{$strategy-risk-reduction-color}; 89 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 90 | color: #fff; 91 | } 92 | 93 | &.technical { 94 | background-color: #{$technical-color}; 95 | background-image: url("#{$baseurl}/assets/images/pattern%20white_1.png"); 96 | color: #fff; 97 | } 98 | } 99 | -------------------------------------------------------------------------------- /_infrastructure-cloud/observability.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Observability 3 | description: Cloud native distributed systems require constant insight into the behavior of all running services in order to understand the system’s behavior and to predict potential problems or incidents 4 | layout: pattern 5 | --- 6 | 7 | ![Observability]({{ site.baseurl }}/assets/images/Observability.png) 8 | 9 | Teams are moving to MS, and there are more and more pieces—the number of components is growing. Traditional responsive monitoring cannot recognize service failures. 10 | 11 | ## In This Context 12 | 13 | Traditional systems practice assumes the goal is for every system to be 100% up and running, so monitoring is reactive—i.e., aiming to ensure nothing has happened to any of these components. It alerts when a problem occurs. In traditional monitoring if a server fails, you will have an event; response, even if automatic, is manually triggered. This assumption is not valid for distributed systems. 14 | 15 | - A distributed system is by definition not 100% stable—when you have so many pieces, some of them will go up and down at random times. 16 | - Resilience is built into the system to handle the assumption that eventually everything in the system will go down at some point. 17 | - The number of components is always increasing while the number of people working on the application remains reasonably stable. 18 | - Always a cost: if you get something, you must pay for it in some way. Here it is complexity, and you must manage it. 19 | - Manual response is never fast enough in a cloud native system. 20 | 21 | ## Therefore 22 | 23 | Put in logging, tracing, alerting, and metrics to always collect information about all the running services in a system. 24 | 25 | - Switch from a centrally planned system to distributed self-governing system. 26 | - Continually analyze availability of services and behavioral trends of the individual services and entire system. 27 | - Instead of focusing on specific pieces of hardware, focus on functional behavior of components. 28 | - Consistently collect as many metrics as possible. 29 | - Analyze the trends. 30 | - Create an interface to make system state accessible to all stakeholders: anyone involved in system maintenance or development who needs to understand the system at any given time must be able to observe the system’s behavior. 31 | 32 | ## Consequently 33 | 34 | There is a continuous overview of the state of the system, visible to anyone for whom this is relevant information. 35 | 36 | {:.plusminus} 37 | - {:.plus} Analytics and proactive monitoring can be used to discover trends, which can be used to predict failure. 38 | - {:.minus} Any response to a single specific failure is extremely difficult. 39 | -------------------------------------------------------------------------------- /_development-design/reproducible-dev-environments.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Reproducible Dev Environments 3 | description: Developers need to test their daily work in an environment that is easy to spin up and that matches production tooling as closely as possible 4 | layout: pattern 5 | --- 6 | 7 | ![Reproducible Dev Environments]({{ site.baseurl }}/assets/images/Reproducible%20dev%20environment.png) 8 | 9 | Developers are building containerized microservices and deploying them to the containerized platform. Each microservice is built by a team, and microservices are interpreted into the larger system. There are many devs on many teams. 10 | 11 | ## In This Context 12 | 13 | Shared environments and databases are difficult to keep in good shape and create dependencies that lead to delays.When developers can’t create their own test environments, they may avoid running proper tests before submitting the code or run them on shared environments that may affect the work of their teammates. This affects other developers by making interpretation more difficult. 14 | 15 | Differences between development environments and the eventual production environment may lead to the introduction of bugs that happen only in production and are related to those differences.In all of these scenarios, product quality and developer productivity suffer. 16 | 17 | - Local testing reduces interpretation problems. 18 | - If setup for the developer environment is too slow, devs will reuse the same environments. 19 | - If not refreshed, local environments tend to undergo configuration drift. 20 | - Shared environments create dependencies that lead to delays. 21 | - Developers tend to create many test environments if it is easy and fast. 22 | - Developers often have multiple changes that require testing at the same time. 23 | - CI and CD are much more difficult to achieve without being able to test each change thoroughly. 24 | 25 | ## Therefore 26 | 27 | Establish a fully automated and fast process to create development environments where devs can test-run their apps. Each developer should be able to have their own environment, or multiple environments, that resemble the eventual production environment. 28 | 29 | - Provide the same (or at least close to the same) tooling to deploy apps as in production. 30 | - It is possible to do this on the cloud but will require cost management. 31 | 32 | ## Consequently 33 | 34 | Each developer can run tests on their own without delays or disturbing the rest of the team. 35 | 36 | {:.plusminus} 37 | - {:.plus} Productivity and product quality are high. 38 | - {:.minus} Could require a lot of hardware to create, at high cost. 39 | - {:.minus} If on cloud, devs may forget to switch them off and accidentally create large use charges. 40 | -------------------------------------------------------------------------------- /_development-design/demo-applications.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Demo Applications 3 | description: Teams onboarded to the new cloud native system receive demo applications as an educational starting point for building their own cloud native applications 4 | layout: pattern 5 | --- 6 | 7 | ![Demo Applications]({{ site.baseurl }}/assets/images/Demo%20applications.png) 8 | 9 | The Core Team has built the initial platform and is ready to start onboarding the rest of the organization to cloud native. Developers have gone through platform trainings and soon need to start moving apps to cloud native. The level of cloud native experience is low. 10 | 11 | ## In This Context 12 | 13 | Teams newly onboarded to cloud native have limited knowledge and no experience creating cloud native applications. They will tend to apply established skills and approaches carried over from previous experience in non-cloud native systems.This will lead to re-creating tightly coupled, interdependent applications—suboptimal architecture that conflicts with cloud native. This reduces overall quality for the apps they deliver and fails to capture cloud native’s development velocity benefits. Re-architecting apps later is much harder than building them the right way in the first place. 14 | 15 | - People tend to use known methods to solve new problems. 16 | - Much easier to start from something rather than nothing. 17 | - People learn by doing and from experiencing examples. 18 | 19 | ## Therefore 20 | 21 | Build a number of simple, functional apps that fully fit cloud native practices.Make those apps known and available to new teams as they join the cloud native setup. Keep the demo apps up to date and adjust them to the latest best practices developed by the Core Team. 22 | 23 | - Applications are basic but fully functional with a UI and a database, and built on microservices architecture with services communicating via APIs. 24 | - Continuously improving—as the teams learn, they can incorporate new tools and methods to expand the application. 25 | - Emphasize clean and high-quality code. 26 | - Tests need to be automated/built in. 27 | - The apps are to be delivered using CI/CD, and the delivery scripts are part of the applications. 28 | - Always up and running—practice Build-Run Teams delivery workflow. 29 | 30 | ## Consequently 31 | 32 | Teams moving to the new system have a way to practice their new skills and prepare to deliver a full enterprise application. 33 | 34 | {:.plusminus} 35 | - {:.plus} Devs can start from the right place. 36 | - {:.plus} Core team can apply their knowledge. 37 | - {:.plus} Architecture is more consistent. 38 | - {:.minus} Demo apps could limit creativity (default effect). 39 | - {:.minus} Core Team spends time on writing demo applications. 40 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/reduce-cost-of-experimentation.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Reduce Cost of Experimentation 3 | description: When someone has an idea that requires validation, the costs of doing experiments around it needs to be as low as possible 4 | layout: pattern 5 | --- 6 | 7 | ![Reduce Cost of Experimentation]({{ site.baseurl }}/assets/images/periodic%20check-ups.png) 8 | 9 | A company is moving into cloud native with little understanding of tooling and technologies.Uncertainty is very high. New ideas and solutions come up all the time, andthe team has to run a variety of validation experiments to select the best ones. 10 | 11 | ## In This Context 12 | 13 | There are significant barriers to experimentation in the organization: permission is required, and the related planning, documentation, and coordination meetings take a lot of time. Then actually getting the results afterward typically requires a significant wait. As a result, engineers will often skip experimentation and move directly to execution. 14 | 15 | - Very little chance that any experiment will lead to canceling a project because there is already high commitment to that path. 16 | - Higher cost means an experiment is less likely to be done. 17 | - If cost is low enough, people can experiment even with things that lead to failure. 18 | - The higher the cost, the lower the willingness to abandon the experiment (sunk-cost effect). 19 | - Traditional organizations require extensive documentation with any experimentation,which by definition makes costs high. 20 | 21 | ## Therefore 22 | 23 | Put in place a simple, straightforward, and seamless process for doing experiments.When experimentation is central to an organization’s process and progress,it needs to be an inexpensive and easily accessible action.Outline and publicize a process, or provide periodic training. for how to create appropriate hypotheses with measures and then design small experiments to test them. Aim to remove bureaucratic roadblocks such as managerial approvals and extensive documentation for every action, while providing technical infrastructure that is light, fully automated, and requires only a tiny budget. 24 | 25 | - Create a framework around experimentation: the tools, facilitation techniques,project-management structure, and guidelines for allocation. 26 | - Such facilitation makes it faster to obtain and understand the results of an experiment. 27 | 28 | ## Consequently 29 | 30 | More experiments take place. Instead of extensive research and guessing when a complex problem arises, a rapid process of hypothesis/results/analysis provides the solution. 31 | 32 | {:.plusminus} 33 | - {:.plus} Teams can be more innovative when they know they can easily try out ideas. 34 | - {:.minus} There is cost to experiments, even if it is low. 35 | -------------------------------------------------------------------------------- /_organization-culture/sre-team.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: SRE Team 3 | description: The SRE (Site Reliability Engineering) team helps the development teams to maintain and improve the application (not the platform or infrastructure) 4 | layout: pattern 5 | --- 6 | 7 | ![SRE Team]({{ site.baseurl }}/assets/images/SRE%20team.png) 8 | 9 | A big company has a large, mission-critical application with very high demands for quality and availability, and significant resources for creating dedicated improvement teams. 10 | 11 | ## In This Context 12 | 13 | Once a platform is built and in production, attention is often directed away from improving internal processes and runtime performance. This can cause degradation over time, reducing quality and performance. 14 | 15 | - Dev teams are measured on functionality, Ops on stability, SRE on improvements. 16 | - SRE is a very expensive team to operate because it requires the most experienced and knowledgeable engineers. 17 | - Opportunity cost arises when you pull your best engineers from development teams to SRE. 18 | - If improvements are the priority for this team, then this is somewhat removed asa responsibility/priority for the Build-Run teams. 19 | - SRE is more relevant when an application enters maintenance mode, rather than during the initial build. 20 | 21 | ## Therefore 22 | 23 | Create a team that is focused 50% on reliability and 50% on continuous improvement of internal processes and development practices.This SRE team worries about overall site (platform) availability overall. However,each individual service has its own operational needs as well. It can be helpful to add SREs into each individual build squad (or at least tribe) to focus on service availability. 24 | 25 | - SRE engineers are in charge of improving whatever it takes to create better infrastructure,better runtime, and better user support. 26 | - The SRE team makes the error budgets and helps the dev team define its operational model and the Platform Team to improve the platform. 27 | - Most tasks are automation rather than manual support. 28 | - Every 18 months the SRE team needs to automate everything it is doing manually(so it can move to the Platform Team’s responsibility). 29 | - You have a highly knowledgeable and experienced team, with good knowledge of operations but also devs who can write code. 30 | 31 | ## Consequently 32 | 33 | The runtime stability and quality is continuously increasing, and automation is also increasing. 34 | 35 | {:.plusminus} 36 | - {:.plus} Developers are aware of operational concerns and incorporate that knowledge into their development cycle. 37 | - {:.plus} The SRE team works closely with the Build-Run teams and the Platform Team. 38 | - {:.minus} SRE teams are expensive and take top engineering talent away from other projects. 39 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/research-through-action.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Research Through Action 3 | description: People can sometimes use research as a way to avoid making decisions, so hands-on learning through small experiments builds confidence and jumpstarts progress 4 | layout: pattern 5 | --- 6 | 7 | ![Research Through Action]({{ site.baseurl }}/assets/images/research%20through%20action.png) 8 | 9 | The challenges are new and complex, information is scarce, and the company is pushing to go fast. 10 | 11 | ## In This Context 12 | 13 | In a new or unfamiliar environment, people can analyze things too much and fail to make progress: analysis paralysis.The tendency is to spend a lot of time on research, because making an actual decision is daunting—particularly in an environment where failure historically resulted in punishment. The effort to take in so much new information can also be overwhelming.As a result, people will often skip from one idea to the next before getting enough understanding to guide informed decision making. All of this adds up to procrastination because it is not effective data gathering related to actually moving ahead with a plan—it is research for research’s sake. 14 | 15 | - When people are not allowed to fail, they avoid taking risks. 16 | - Quick actions carry a lot of risk. 17 | - If the cost of action is high, people tend to delay and wait for more info. 18 | - In a world with many dependencies, taking action requires involving others. 19 | 20 | ## Therefore 21 | 22 | Run small experiments instead of full analysis and research; choose action over extensive contemplation and exhaustive research.We all find ourselves from time to time in front of a massive pile of work without the faintest idea where to start. Doing nothing is the easiest choice, of course, but this won’t lead very far. So then we try some thorough planning to “make sense” of all these tasks, doing lots of reading and Googling. In an uncertain environment, however,we won’t be much smarter after all that work—the best course of action is to simply pick the first task from the pile and do it! Then another one and another one.Keep doing this until you gather enough information about what’s going on, and at that point a bit of planning could be appropriate. 23 | 24 | - Experiments and PoCs instead of in-depth architectural documents. 25 | - Limit the risk of action with short deadlines and low cost. 26 | 27 | ## Consequently 28 | 29 | You are making minor yet tangible progress through taking small, iterative steps. 30 | 31 | {:.plusminus} 32 | - {:.plus} Uncover unknown-unknowns through experimentation. 33 | - {:.plus} Increase team motivation and joint learning. 34 | - {:.plus} Many experiments fail—this is OK. 35 | - {:.plus} A solution that is not fully baked can still be a valid choice. 36 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/big-bet.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Big Bet 3 | description: When enough information is available, commit to a significant solution for moving thecloud migration forward. Focus on execution rather than research. 4 | layout: pattern 5 | --- 6 | 7 | ![Big Bet]({{ site.baseurl }}/assets/images/big%20bet.png) 8 | 9 | A company is facing a big technical or organizational decision. Experiments were performed, research done, major points validated, and the team has a good understanding of the company’s needs and the problem domain. Multiple major directions are still open. 10 | 11 | ## In This Context 12 | 13 | Continuing research and experimentation without ever making any big decision leads to significant waste of resources as the teams are not focused on solving the problem and the direction is not chosen yet. It means that there is no clear alignment across teams regarding a solution, and no stable and focused delivery process has been established. 14 | 15 | - In Waterfall, teams tend to do too much research and try to find all the answers for all questions. 16 | - Many times any decision is better than none. 17 | - Large corporations hate risk and therefore push for more research. 18 | - In Waterfall organizations, managers’ success is measured by their ability todecide on and execute major changes. 19 | 20 | ## Therefore 21 | 22 | Make a commitment to a large-scale solution, like a large rebuild, architectural change, migration, purchase of new products, etc., bearing in mind that it might require organizational change.After exploring the options with No Regret Moves and increasing the chance of success even more with Options and Hedges, we now can make a big commitment toward the right longer-term solution. Once the commitment is made, the teams switch from research to execution mode, provided there are no significant changes in the market or other game-changing information. This creates alignment among teams and allows quick product delivery, without endless discussions about the direction. 23 | 24 | - Make the commitment clear to the team. 25 | - Stop doing competing projects. 26 | - Consider an exit strategy (evaluate related costs should it be necessary to reverse the decision). 27 | 28 | ## Consequently 29 | 30 | There is full commitment to the chosen direction. It is clear to everyone that this is a commitment moment: at this time we stop experimenting and move forward.Unless there is a significant change in market or strategy conditions, teams stay committed to the chosen path. 31 | 32 | {:.plusminus} 33 | - {:.plus} A single solution is chosen, and the team is focused on making it work. 34 | - {:.plus} No effort is wasted on work that doesn’t improve the decision process. 35 | - {:.minus} There is always a chance that the decision can turn out to not be the right one. 36 | -------------------------------------------------------------------------------- /_operations/dynamic-secrets.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Dynamic Secrets 3 | description: Use a specific tool for managing and abstracting secret data from your applications. 4 | layout: pattern 5 | --- 6 | 7 | ![Dynamic Secrets]({{ site.baseurl }}/assets/images/dynamic_secrets.png) 8 | 9 | The team is building applications using distributed microservices architecture. The secrets required by multiple services and environments need to be managed in a manner that doesnt negatively impact agility or security. 10 | 11 | ## In This Context 12 | 13 | Building a distributed, microservices architecture. Many services require passwords, keys, tokens or other sensitive data which cannot be stored in plain text. 14 | 15 | Teams tend to end up with one of two sets of problems: 16 | 17 | ##### High Security - Low Agility 18 | 19 | - All credentials are managed (manually) by a security team. Nobody usually knows where this team actually sits, there only interface is an obscure ticket filing system. 20 | - Developers must submit requests to have the necessary credentials created and made available to their application. 21 | - Developers invent 'hacks' to work around the missing credentials locally or on a dev environment. 22 | 23 | ##### High Agility - Low Security 24 | 25 | - Dev teams are responsible for managing their own secrets. 26 | - Credentials are often omitted or set to defaults (admin:admin) in all but production. 27 | - Production credentials are often accessible to nearly everyone, resulting in a large security risk. 28 | - Secrets in this case are almost never rotated. 29 | 30 | In both cases: 31 | 32 | - Upon deploying their application to a new environment (e.g. local dev to integration or qa to prod) the applications most often fail because the credentials or how the credentials are accessed differs across each environment. 33 | - Applications are heavily coupled to the specific tool and method for retrieving credentials. 34 | 35 | ## Therefore 36 | 37 | Use a specific tool for managing and abstracting secret data from your applications. 38 | 39 | - Abstract the tool as well as the method for retrieving secret data from your services. 40 | - Adding/requesting a new secret (e.g. database password) should be self service. 41 | - Secret data is mounted as a volume for applications to read locally. 42 | - Secrets should be rotated often. 43 | - Secret data must be encrypted at rest. 44 | 45 | ## Consequently 46 | 47 | Secrets can be managed without any negative impact to agility without compromising security. 48 | 49 | {:.plusminus} 50 | - {:.plus} Developers do not have to worry about how or from where to retrieve secret data. 51 | - {:.plus} The security team does not need to slow down or stop the release process. 52 | - {:.plus} Secret data is well protected, ideally no human will ever see the actual secrets. 53 | - {:.plus} Risk is greatly reduced as even if compromised, secrets can be easily revoked or rotated. 54 | 55 | 56 | -------------------------------------------------------------------------------- /_organization-culture/productive-feedback.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Productive Feedback 3 | description: People are more engaged and creative when they feel comfortable receiving constructive information about their behavior and giving the same in return 4 | layout: pattern 5 | --- 6 | 7 | ![Productive Feedback]({{ site.baseurl }}/assets/images/Honest%20feedback.png) 8 | 9 | A team whose main responsibility requires creative or innovative work. 10 | 11 | ## In This Context 12 | 13 | People are often blind to their own biases and live in their own bubble without realizing it.During a cloud native transformation, teams that have always worked in a proficient way now are tasked with innovation. They have no experience being creative,so they will keep using past solutions to attempt to solve new problems.Lacking external perspective you will be blind to your own confirmation bias and interpret results to fit your preconceived notions, leading the project to very poor results. At the same time, other people within the organization can clearly see the problems before they happen. 14 | 15 | - Judgmental tendencies are hardwired. 16 | - Most people don’t give positive feedback unless prompted to do so. 17 | - Without empathy, feedback can be perceived as aggression or attack. 18 | - For people who have never given feedback it can be difficult to start. 19 | - An existing team has already solidified their relationships and will find it difficult to change their behavior. 20 | - Significant feedback requires some level of personal relationship. 21 | 22 | ## Therefore 23 | 24 | Create a safe environment and simplify ways for people to give feedback—positive,negative, even confrontational—in a constructive way.Facilitate team activities to build personal connections between team members; this helps to create a sense of mutual trust that allows feedback to flow freely.- Offer training or tools to teach people how to give constructive feedback. 25 | 26 | - Create opportunities, such as one-on-one or group meetings or weekly email updates on the project, to exercise giving constructive feedback. 27 | - If someone is doing something well, feel comfortable giving them praise. 28 | - If you think someone is taking a wrong approach, tell them in a constructive way. 29 | - Someone needs to act as leader to model how to do all this. 30 | - Psychological safety is an essential prerequisite for Productive Feedback. 31 | 32 | ## Consequently 33 | 34 | Productivity goes up because people can learn and improve their work and behavior,and because they feel seen and appreciated. 35 | 36 | {:.plusminus} 37 | - {:.minus} There are costs involved: honest and constructive feedback relies on personal relationships and psychological safety. 38 | - {:.minus} High risk of personal conflict, but this is the chance you have to take if you really want to go fast. People will learn on their own without feedback, but it will take a lot longer, and some things they will never learn on their own. 39 | -------------------------------------------------------------------------------- /_infrastructure-cloud/continuous-deployment.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Continuous Deployment 3 | description: Continuous Deployment automatically and seamlessly pushes code that has been accepted in the Continuous Integration/Continuous Delivery cycle into the production environment 4 | layout: pattern 5 | --- 6 | 7 | ![Continuous Deployment]({{ site.baseurl }}/assets/images/continuous%20deployment.png) 8 | 9 | The team is using Continuous Delivery and building a distributed system using microservices. There is no regulation nor any other restriction on fully automated delivery. 10 | 11 | ## In This Context 12 | 13 | Changes are frequently delivered to a production-like environment in a quick and automated way, but then they get stuck there.Many teams using CI/CD still have a human gate at the end, meaning that beforechanges can go live they may need to wait for the Ops team to do extensive testing,whether automated or manual, and/or wait for manual deployment. This means changes are not tested in a real live environment and carry high deployment risk duet o potential differences in tools and processes. Time to market is slower; release manager delays releases due to risk and complexity. 14 | 15 | - Any handover point slows down the process and introduces risk. 16 | - Some industries have regulations that define roles during development and deployment (for example, release must be manually approved by a designated person of responsibility, as is common in financial sector regs). 17 | - Frequent delivery better helps perceive customer needs. 18 | 19 | ## Therefore 20 | 21 | Create a fully automated deployment process to take all changes to production all of the time. Use gradual deployment strategies and prepare for failure mitigation.Every change committed to the source code repository needs to be tested and ready for delivery to production at any given moment based on business needs and according to the relevant regulations. 22 | 23 | - Build in full automation throughout system. 24 | - No team or service dependencies are allowed. 25 | - Make sure there is very good overview of the content and risks to the release manager. 26 | - In case of regulatory restrictions that require a manual delivery step, automate everything before and after the release review point and make the release point as simple as pressing a button. Provide sufficient information to the release manager to allow fast and sound decisions. 27 | 28 | ## Consequently 29 | 30 | Speed of delivery to customers is very high, and the changes are flowing to the customers daily or even hourly. Products or services are continuously providing higher value to the customers while allowing the developers to get real live feedback very quickly and learn and improve the products even further. 31 | 32 | {:.plusminus} 33 | - {:.plus} Experiments can be done quickly and changes rolled back if necessary. 34 | - {:.minus} Some issues can still sneak in. 35 | - {:.minus} You have less control over feature release cadence. 36 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/learning-organization.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Learning Organization 3 | description: An organization skilled at acquiring information, creating insight, and transferring knowledge can tolerate risk with confidence and solve difficult problems through experimentation and innovation 4 | layout: pattern 5 | --- 6 | 7 | ![Learning Organization]({{ site.baseurl }}/assets/images/Learning%20organization.png) 8 | 9 | A company is launching a cloud native transformation and needs to create a new culture in the organization that supports innovation and accepts uncertainty. In the new and complex world of cloud native technology, there is no “right” way to go about acloud native transformation. 10 | 11 | ## In This Context 12 | 13 | Organizations migrating from Waterfall or Agile paradigms to cloud native don’t typically have the skill set for working in a highly uncertain and ambiguous environment:open-mindedness, a willingness to experiment and tolerate risk, and above all the ability to enter into the transformation process without a detailed map.Traditionally, before starting large projects managers would require all the answers and full work estimations. Then once the project was approved there would be no real possibility to adjust course. Such bureaucratic habits reinforce stability and reduce risks by eliminating change, but they conflict with the need to innovate and lead to re-creating the same old monolithic systems and organization, only now with newer tools. 14 | 15 | - Teams are coming in with proficient, rather than creative, skills. 16 | - Innovation requires the ability to tolerate risk and ambiguity. 17 | - The process of innovation depends on failures and improvements over time. 18 | - Few people are trained to think or work in a creative, open-ended way. 19 | 20 | ## Therefore 21 | 22 | Take an honest look at your current culture. Build in the willingness to accept ambiguity and risk as part of your daily organizational process.Rather than demanding a full detailed plan with clear estimation upfront, embrace Dynamic Strategy and help teams to structure effective experiments. Make sure there is enough Psychological Safety to allow people to take risks. 23 | 24 | - Leaders need to lead by example and show everyone that it’s safe to try new things even if they fail. 25 | - Consider your company’s current relationship to risk and change. Does experimentation require permission? Is failure considered automatically “bad”? 26 | - Treat change as an opportunity rather than a cause for anxiety. 27 | 28 | ## Consequently 29 | 30 | Teams are co-creating solutions and challenging each other with Productive Feedback as they experiment their way toward the right answers. 31 | 32 | {:.plusminus} 33 | - {:.plus} People learn how to act autonomously while being willing to fail—and then mine what went wrong so they can learn from it. 34 | - {:.minus} Training for cognitive resilience and creativity is possible, but it requires investment and work. 35 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/learning-loop.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Learning Loop 3 | description: Building feedback collection into the delivery process closes the loop between engineers and the people who use their products, putting the customer at the center of the product development cycle 4 | layout: pattern 5 | --- 6 | 7 | ![Learning Loop]({{ site.baseurl }}/assets/images/Learning%20loop.png) 8 | 9 | A company is working to transform its culture to align with the delivery approach required by cloud native’s distributed architecture of containerized microservices delivered via the cloud. 10 | 11 | ## In This Context 12 | 13 | Learning happens in a three-part cycle: goal-setting, execution, and reflection. The first stage is identifying a challenge or problem and devising a likely solution. The second stage is carrying out the plan until it succeeds or fails. The third is studying the result—thinking back over what happened and how it worked out. In avery long delivery process this cycle is of limited use when lessons learned can be applied only months later, when the information is not fresh in the developer’s minds or perhaps no longer relevant.The learning loop is useful in an organizational context only when it is closed(one stage leads directly to the next and the next, then the cycle repeats).Most companies adopting cloud native cite increasing product velocity as their main motive.Tightly coupled Waterfall-approach release cycles may be as long as six months to one year, or even two. 14 | 15 | ## Therefore 16 | 17 | Build mechanisms for collecting user feedback and feeding it rapidly back into the delivery cycle, enabling responses to flow back from the customer so the business can make better-informed decisions.In cloud native, organizations can make extremely effective use of this three-part learning cycle as a feedback loop to developers that allows for fast iteration and adaptation to changing market conditions and customer needs. When a team is building its piece of an application and deploying it quickly and frequently to production, the team’s work gets in to users right away. If client feedback is collected at that point, itcan be fed directly into the reflection stage for the team to take into consideration as the loop repeats and the team sets goals for its next work cycle.Use the feedback to create the changes customers are telling you they want.Not collecting feedback decreases the value of cloud native’s shorter time to market. 18 | 19 | ## Consequently 20 | 21 | Apply Data-Driven Decision Making to cloud native’s rapid delivery cycle so that the output of the system continually goes back in to improve the system (you can go fast without breaking things). 22 | 23 | {:.plusminus} 24 | - {:.plus} Developers capture the momentum of improvements, leading to more improvements. 25 | - {:.minus} Observability is complicated and needs to be carefully engineered to provide the right insights. 26 | - {:.minus} What customers want is not always feasible or cost-effective. 27 | -------------------------------------------------------------------------------- /_infrastructure-cloud/private-cloud.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Private Cloud 3 | description: A private cloud approach, operated either over the internet or on company-owned on premises infrastructure, can offer the benefits of cloud computing services like AWS while restricting access to only select users 4 | layout: pattern 5 | --- 6 | 7 | ![Private Cloud]({{ site.baseurl }}/assets/images/private%20cloud.png) 8 | 9 | A company in a highly regulated industry that is, by law, not allowed to use public cloud or a company in any sector that has recently made a major investment in new on-premises infrastructure. In the Private Cloud context, services are provisioned over private—though not necessarily on-premises—infrastructure for the dedicated use of a single organization and typically managed through internal resources. 10 | 11 | ## In This Context 12 | 13 | Connecting designated hardware to specific apps reduces their mobility and resilience.Building any kind of manual intervention by the Ops team into an application’s life cycle will create long delays in deployment and reduce quality. 14 | 15 | - There is a lot of fear around data on the public cloud. 16 | - Public cloud vendors are very knowledgeable about, and experienced in, running large infrastructure. 17 | - In much of the world, public cloud is allowed for almost all industries. 18 | - A private cloud is under full control of the company, so you can optimize in different ways and customize different things that are not possible on public clouds. 19 | - Proficient support is required to keep private clouds up and running, so you must have all that knowledge in your (typically limited) team. 20 | 21 | ## Therefore 22 | 23 | Decouple the setup of your physical infrastructure from the provisioning required for the application itself.Treat all the servers and the rest of the infrastructure as a single large machine managed fully automatically through a set of APIs. Aim to use the same set of tools as would be required on at least one public cloud to ease any future migration. 24 | 25 | - Fully automate everything related to running the application. 26 | - Treat your on-premises infrastructure like a cloud; the hardware needs to be completely abstracted away from the users. 27 | - Set up physical servers, network, storage, etc., all separately. 28 | - Deploy and maintain applications through full APIs. 29 | - Even if you need dedicated hardware, treat it as a part of the cloud so it is fully automated. 30 | 31 | ## Consequently 32 | 33 | The company enjoys the benefits of cloud native architecture with the additional control and security—but also expense—of hosting your own private cloud setup.Applications are running on the private cloud in exactly the same way as they would run on a public cloud. 34 | 35 | {:.plusminus} 36 | - {:.plus} Developers can get infrastructure on their own, and delivery is faster. 37 | - {:.plus} There is full control over the platform and data. 38 | - {:.minus} Private clouds carry a high cost of ownership and quickly become outdated. 39 | -------------------------------------------------------------------------------- /_organization-culture/personalized-relationships-for-co-creation.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Personalized Relationships for Co-Creation 3 | description: Solutions to complex problems are best created collaboratively by teams with high levels of interpersonal connection 4 | layout: pattern 5 | --- 6 | 7 | ![Personalized Relationships for Co-Creation]({{ site.baseurl }}/assets/images/Personalised%20Co-creation.png) 8 | 9 | The team is working on the more creative part of the implementation and still is only partially knowledgeable about it. There are no immediate answers, and the future is not clear or predictable. Teams are based on personal expertise and have clear roles and responsibilities. 10 | 11 | ## In This Context 12 | 13 | In uncertain environments, what worked in the past may not work here, so you need to invent rather than attempt to reuse existing solutions. 14 | 15 | - Creativity requires trust and volunteering information. 16 | - By default people will use existing knowledge to solve a problem. 17 | - People will not volunteer information to an expert. 18 | - They will only volunteer when there is trust and a personalized connection. 19 | - New solutions are best achieved in highly collaborative, small creative teams. 20 | 21 | ## Therefore 22 | 23 | In complex environments where there is no clear path forward, a strong team needs personalized relationships to collaborate on creative solutions. Creativity is not the goal—co-creation is the goal. Creativity is open-ended and may not lead to anything, but co-creation generates results.Cloud native is better suited to co-creative relationships where the team itself collaborates on the future solution with all team members participating. People are solving the problem together rather than relying on the expert advice of individual members.Co-creation teams are significantly more innovative and creative because people are thinking together and drawing from group understanding and experience. They workby building mutual trust, volunteering extra information, and being willing to take risks as a group. 24 | 25 | - To create closer relationships, literally reduce the physical distance between team members. Teams should share the same workspace whenever possible. 26 | - Run trust-building experiences, bringing people together to build personal relationships. 27 | - Encourage collaboration and co-creation by working in groups. 28 | 29 | ## Consequently 30 | 31 | The team has established trust and a relationship that helps people share information effectively, which leads to co-creating new solutions. 32 | 33 | {:.plusminus} 34 | - {:.plus} Each person on the team is helping to create solutions. 35 | - {:.plus} The team as a whole is more creative than each individual. 36 | - {:.plus} People have individual expertise, but they contribute it to the wider team objectives. 37 | - {:.minus} Effort is required to bring people together for social events, extra activities, etc.Not just money and time, but also psychological safety and other organizational culture aspects that take investment. 38 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to Cloud Native Patterns 2 | We love your input! We want to make contributing to this project as easy and transparent as possible, whether it's: 3 | 4 | - Reporting a bug 5 | - Discussing the current state of the patterns 6 | - Submitting a fix 7 | - Proposing new patterns 8 | - Becoming a maintainer 9 | 10 | ## We Develop with Github 11 | We use github to host code, to track issues and feature requests, as well as accept pull requests. 12 | 13 | ## We Use [Github Flow](https://guides.github.com/introduction/flow/index.html), So All Code Changes Happen Through Pull Requests 14 | Pull requests are the best way to propose changes to the patterns. We actively welcome your pull requests: 15 | 16 | 1. Fork the repo and create your branch from `master`. 17 | 2. If you've added a pattern, double check for typos 18 | 3. If you've changed a pattern, explain your changes with a comment in the PR 19 | 5. Make sure your patterns are following the structure of the pattern 20 | 6. Issue that pull request! 21 | 22 | ## Any contributions you make will be under the `Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License` 23 | In short, when you submit pattern changes, your submissions are understood to be under the same [CC 4.0 License](https://creativecommons.org/licenses/by-nc-sa/4.0/) that covers the project. Feel free to contact the maintainers if that's a concern. 24 | 25 | ## Report bugs using Github's issues 26 | We use GitHub issues to track public bugs. Report a bug by [opening a new issue](https://github.com/ContainerSolutions/cloud-native-patterns/issues/new/choose). 27 | 28 | ## Write issue reports with detail, background and explanation 29 | 30 | **Great Issue Reports** tend to have: 31 | 32 | - A quick summary and/or background 33 | - What you expected should be included in the pattern 34 | - Notes (possibly including why you think this might be needed) 35 | 36 | ## Use a Consistent Pattern Layout 37 | The pattern should use the following layout: 38 | ```markdown 39 | 40 | --- 41 | title: 42 | description: <1 line summary of pattern> 43 | layout: pattern 44 | --- 45 | 46 | ![]({{ site.baseurl }}/assets/images/generic.png ) 47 | 48 | 49 | 50 | ## In This Context 51 | 52 | 53 | 54 | ## Therefore 55 | 56 | 57 | 58 | ## Consequently 59 | 60 | 61 | 62 | 63 | {:.plusminus} 64 | - {:.plus} 65 | - {:.minus} 66 | 67 | ``` 68 | 69 | ## License 70 | By contributing, you agree that your contributions will be licensed under its CC 4.0 71 | 72 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/exit-strategy-over-vendor-lock-in.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Exit Strategy Over Vendor Lock-in 3 | description: Public cloud or other major product vendors can handle all aspects of building and operating a cloud native platform, and their tools are often excellent—but when committing to a vendor/technology/platform, it’s important to identify an alternate solution and any costs associated with switching over 4 | layout: pattern 5 | --- 6 | 7 | ![Exit Strategy Over Vendor Lock-in]({{ site.baseurl }}/assets/images/exit%20strategy%20over%20vendor.png) 8 | 9 | Companies need to use tools/products provided by vendors (commercial or open source communities) but are afraid to get locked into a single vendor. Some industries require supporting multiple choices for some key platforms, tools, or technologies used to develop company products. Being fully committed to a single tool or technology can drive costs up or hinder tech progress down the line. 10 | 11 | ## In This Context 12 | 13 | Committing to a single-vendor (or simply a single large solution) creates reliance upon their ongoing stability and availability and pricing, but the cost of maintaining active alternative/backup options is prohibitive.This leads to full dependency on the vendor. If the vendor is in trouble or when a better option becomes available on the market, the company cannot afford to switch—which leads to using unmaintained or inferior technology. 14 | 15 | - There is risk in any choice. 16 | - Every decision can be reversed; it’s just a matter of cost. 17 | - Some industries require multiple vendors for each solution. 18 | 19 | ## Therefore 20 | 21 | Instead of blindly refusing to commit to a single vendor, explore the options for a second migration, if necessary, and what they would cost. Then make an educated decision based on the tradeoff between short-term gains from a vendor with the best tool and the long-term risk of migrating out of it if needed. Often lower costs and higher productivity outweigh the risk. 22 | 23 | Consider implementing architectural changes that will reduce the cost of migration in case it will be required. Such changes can be inexpensive if done in the earliest stages of the project, and they can significantly reduce the risk of the future migration. 24 | 25 | - Prepare a migration plan just in case. 26 | - Consider reducing dependencies that significantly increase risk. 27 | - AWS could be a big help now. 28 | - Closed ecosystems often offer an excellent set of tools/options. 29 | - Invest in commonly used tools and technologies that may become industry standards. 30 | 31 | ## Consequently 32 | 33 | The team can focus on getting the maximum performance out of and benefit from each tool, and they are aware of what it would cost to migrate to alternative solutions should the need arise. 34 | 35 | {:.plusminus} 36 | - {:.plus} There is a good understanding of the different backup options. 37 | - {:.plus} High-level plan is in place for a major migration scenario. 38 | - {:.minus} There is always risk when only one tool is used. 39 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/business-case.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Business Case 3 | description: Before launching a cloud native transformation, an enterprise’s leadership must makesure the initiative is needed and that the benefits will justify the investment 4 | layout: pattern 5 | --- 6 | 7 | ![Business Case]({{ site.baseurl }}/assets/images/business%20case.png) 8 | 9 | A company is experiencing pressure, whether from the market or internally, to moveto cloud native. The executive team is contemplating making the move to cloudnative, but there is little internal knowledge of cloud native tech and culture orunderstanding of its benefits. 10 | 11 | ## In This Context 12 | 13 | Cloud native transformations are a big commitment, requiring significant investment of budget, time, and team talent. Too many organizations, though, get caught up in the hype of the cloud conversation and make decisions without understanding how exactly a transformation fits their business needs and goals.The risk is especially high for organizations that have already established rapid and significant internal momentum toward making this move. 14 | 15 | - The traditional model is for organizations to be massively risk-averse to minimize uncertainty at all costs. 16 | - Change-averse culture avoids new technologies or experimental approaches.Cloud native architectures are conceptually different from traditional approaches, merging careful upfront planning with flexible and mutable,experimentation-based implementation. 17 | - Tech teams are eager to get started with the transformation, even before a business case is established. 18 | - Cloud native is complex, and the benefits are not easily visible. 19 | - Companies often don’t have good baselines for how much it actually costs them to do development in their current approach, so trying to evaluate cost savings or time savings in a new approach is difficult. 20 | 21 | ## Therefore 22 | 23 | Create a formal business case to help educate the organization’s executive team, to evaluate how the transformation will serve the company’s goals, and to create a clear vision for where the organization is headed. 24 | 25 | - Discussion should involve business stakeholders, as well as information gathering interviews with internal and external resources. 26 | - Explain key cloud native advantages, including acceleration of business velocity,resilience, scalability, potential cost savings, and the ability to quickly act on feedback from customers to improve products. 27 | - Evaluate the realistic scope and cost of the transformation, including technical and organizational changes. 28 | 29 | ## Consequently 30 | 31 | The business case for a cloud native transformation is clear. The company’s decision makers have a clear understanding of the initiative and the advantages it willconfer when complete. They are ready to move forward. 32 | 33 | {:.plusminus} 34 | - {:.plus} They are prepared to allocate the necessary budget and resources that such a large project will require. 35 | - {:.plus} Enhanced recruitment and retention of tech staff eager to work with modern systems. 36 | -------------------------------------------------------------------------------- /_organization-culture/decide-closest-to-the-action.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Decide Closest to the Action 3 | description: Those nearest to a change action get the first chance to make any decisions related to it 4 | layout: pattern 5 | --- 6 | 7 | ![Decide Closest to the Action]({{ site.baseurl }}/assets/images/Decide%20closest%20to%20action.png) 8 | 9 | Cloud native transformation is underway, and there is a lot of uncertainty. People are still learning about the tech, which itself is continually evolving, and the market is changing frequently and erratically. Each team is responsible for delivering its own microservice, and there are many moving pieces. Managers and lead architects have only a broad, high-level understanding of the product and little grasp of the technical details that underlie the actual development process. 10 | 11 | ## In This Context 12 | 13 | Decision making via chain of command is not sustainable in cloud native. Using hierarchy to resolve conflicts and agree on decisions takes too long, and solutions are limited to the capabilities of the managers making that level of decision. Engineers might find a superior solution that never gets implemented because it takes too much time and effort to navigate the bureaucracy to get permission. So they will give up and just move on with whatever they have. 14 | 15 | - Recent speed of technological change is growing exponentially. 16 | - Market is now also changing frequently, with unexpected new competitors appearing. 17 | - In traditional organizations, managers make all the decisions and give instructions to engineers. 18 | - Further you go from the change, the slower the decision over time. 19 | 20 | ## Therefore 21 | 22 | Push the decision power as close as possible to any change as it is happening. It is typically best if the dev team itself makes the decisions.Because your team works as part of a bigger tribe of teams, sometimes your decision must involve others. For example, if you want to change APIs, you must inform those who use them—and they may object to the change. So whatever happens inside of a microservice is fully the domain of its development team, but anything going in/outis also the domain of the teams that consume them. 23 | 24 | - Put in place security and regulation to make sure people are allowed to make these decisions. 25 | - Complete separation of duties: execs in charge of strategy, managers in charge of setting objectives, engineers free to execute their work as they see best. 26 | - Instill that it’s OK to fail into the organization’s values. 27 | - Use hierarchical management for conflict resolution. 28 | 29 | ## Consequently 30 | 31 | Executives delegate the power to create the vision and objectives to middle management,and middle managers delegate power over technical decisions to the execution teams. 32 | 33 | {:.plusminus} 34 | - {:.plus} Strong incentive to resolve conflicts first within team, then within tribe, only then go to management. 35 | - {:.minus} Time and effort are required to coordinate with any teams who are consuming your particular service to make sure it works all around. 36 | -------------------------------------------------------------------------------- /_development-design/avoid-reinventing-the-wheel.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Avoid Reinventing the Wheel 3 | description: When possible, use open source or purchase commercial solutions for any need that is not your actual core business instead of trying to custom-build perfect tools 4 | layout: pattern 5 | --- 6 | 7 | ![Avoid Reinventing the Wheel]({{ site.baseurl }}/assets/images/avoid%20reinventing%20the%20wheel.png) 8 | 9 | A team is in the middle of a cloud native transition and missing some functionality.Out-of-the-box solutions are available on the market, although the team is capable of creating its own. 10 | 11 | ## In This Context 12 | 13 | Many development teams tend to create their own tools/solutions even when reasonable alternatives are available. Custom solutions are expensive and slow to build, difficult to maintain, and quick to become outdated. They don’t take advantage of developments in the industry, and the eventual cost is high. 14 | 15 | - Internal devs are most content to build core products. 16 | - Tools that are not core business rarely get full attention. 17 | - Everything that is not business logic or user interaction is not your core business. 18 | - Every off-the-shelf product is a core business for the company or the community that makes it. 19 | - Cloud native ecosystem is growing very fast. 20 | - Many engineers think “they know better.” 21 | - Open source attracts many devs. 22 | 23 | ## Therefore 24 | 25 | Use existing tools whenever possible, even when the fit isn’t perfect. 26 | 27 | Whether commercial or open source, existing products are typically better quality,better maintained, and more frequently extended than anything you can build yourself.Spend most of the development time on your core business functionality. This will significantly increase the time and effort available for investment into the core business parts that separate your company from the competition, while making sure that the rest of the components are easily maintainable and up to the latest industry standards. 28 | 29 | - Make use of third-party libraries, off-the-shelf products, and existing architectures when possible. 30 | - Focus your internal resources on delivering your core business. 31 | - Build only if nothing else is available; give preference to an open source solution unless it’s related to your core business. 32 | - Seek the fullest possible solution; trying to fit together a variety of open source solutions, each addressing a separate business function, can lead to maintaining a complex environment of many moving parts. 33 | 34 | ## Consequently 35 | 36 | The team can focus on core business. 37 | 38 | {:.plusminus} 39 | - {:.plus} New functionality is constantly introduced with third-party product releases. 40 | - {:.plus} Quality of off-the-shelf products is typically higher. 41 | - {:.plus} There is external product/user support. 42 | - {:.plus} Easier to hire people when using common tools. 43 | - {:.minus} Some problems are too specific for any off-the-shelf solution to address. 44 | - {:.minus} Third-party products are often expensive. 45 | - {:.minus} Less control over functionality. 46 | -------------------------------------------------------------------------------- /_organization-culture/mvp-platform.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: MVP Platform 3 | description: Once Exploratory Experiments and PoCs have uncovered a probable path to success, build a simple version of a basic but fully functional and production-ready platform with one to three small applications running on it in production. 4 | layout: pattern 5 | --- 6 | 7 | ![MVP Platform]({{ site.baseurl }}/assets/images/(platform)%20MVP.png) 8 | 9 | The goal is clear, the tech is available, and knowledge is present, and all major questions are answered by a series of PoCs. Now is the time to build a real platform. Development teams are on hold and waiting for the new platform to start building new applications and refactoring old ones. 10 | 11 | ## In This Context 12 | 13 | Trying to add too many functions to the first release will make it very protracted and delay any release to production. In the traditional Waterfall approach a new platform will be used in production only if it’s fully finished and everything is ready. Building a fully featured cloud native platform may take up to three years, but since cloud native components work independently, the platform can be running apps in production even before it’s completely built out. Not using the platform or any of its features until it is 100% complete would be a lost opportunity. 14 | 15 | - Minimum basic functionality could be built in a fraction of the time it takes to build the full system. 16 | - There is always something to remove from the list of critical features. 17 | - Custom complex solutions are difficult to build and maintain. 18 | 19 | ## Therefore 20 | 21 | Define and build a system with minimal useful—and production-ready—functionality on a quick timeline. It’s important to release something quickly in order to start getting real feedback so you can then improve things based on that user response. 22 | 23 | - “Minimal usefulness” can vary per company. 24 | - Cloud native Platform MVP should take two to six months to produce. 25 | - Build good basics and quality to reduce the need for user support, but don’t go overboard. 26 | - Extendability is critical. 27 | - Plan additional two to three phases to bring the platform to full functionality. 28 | - Use experiments and PoCs to define the MVP. 29 | - Stress assumptions in real life—build a system that works with how people will need and want to use it. 30 | 31 | ## Consequently 32 | 33 | The first MVP of the platform is ready and can be used by a small number of development teams to deliver a few apps to production. The Platform Team has a plan to expand the scale and functionality of the platform as it continues rolling it out to the rest of the organization. 34 | 35 | {:.plusminus} 36 | - {:.plus} Teams can begin learning the basics of using a cloud native platform even while the final production version is still being developed. 37 | - {:.minus} The MVP represents 20%–40% of the final platform; further effort is still required to build out a complete, production-ready platform. 38 | - {:.minus} Core team needs to do support for this version while continuing to develop the production platform that will eventually replace it. 39 | -------------------------------------------------------------------------------- /_strategy-risk-reduction/dynamic-strategy.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Dynamic Strategy 3 | description: Today’s tech-driven marketplace is a constantly shifting environment, no matter whatbusiness you are in—so your game plan needs to shift right along with it 4 | layout: pattern 5 | --- 6 | 7 | ![Dynamic Strategy]({{ site.baseurl }}/assets/images/Dynamic%20strategy.png) 8 | 9 | A company is commencing a cloud native transformation, has completely and successfullymigrated its platform, or is at any point along the way. Traditionally, companiescould set strategy, translate to objectives, and then move comfortably into longtermexecution without ever looking back to re-evaluate. Today’s environment isuncertain and constantly changing. Cloud native evolved in response to this reality asa nimble, scalable, and fast framework for handling constant variability. 10 | 11 | ## In This Context 12 | 13 | Not responding quickly enough to market changes or new information may lead the company to continue building products according to an old strategy that is no longer fully relevant. The original strategy could be realized in its totality, but in the meanwhile competitors could come up with better products, technology could change, and much better opportunities could be missed.Ultimately, the company may end up with exactly what was planned in the beginning of the project—only to find that this is not what they actually need when they finally go to market. 14 | 15 | - New technologies are constantly introduced, bringing unexpected new competitors to every sector. 16 | - Low-certainty projects carry extremely high risk. Any decision made early in the project is highly likely to be uncovered as a wrong decision later. 17 | 18 | ## Therefore 19 | 20 | Continually re-evaluate circumstances as the initiative moves forward.Check if the relevant products are still in demand and if the chosen technologies,organizational structure, and development processes are still the best for the most successful delivery. Always monitor the competition to adjust delivery planning and releasing optimal functionality to maximize market impact.\` 21 | 22 | - If adjustment is required, use the Gradually Raising the Stakes pattern to reduce risk and make better decisions. 23 | - Dynamic Strategy is essential for doing cloud native right, from inception to completion. This pattern is so essential that it is built into our transformation design from the beginning. 24 | - Use Reflective Breaks for the executive team to review and reassess strategy. 25 | 26 | ## Consequently 27 | 28 | The executive leaders are aware when the environment changes and adjust strategic goals to keep the company heading in the right direction. 29 | 30 | {:.plusminus} 31 | - {:.plus} Digital transformation is a constant balancing act between innovation and pragmatism—delivering what earns the company’s money right now. 32 | - {:.plus} If a disruptive new competitor enters the market unexpectedly, the CEO and board can shift the company toward increased creativity to keep up. 33 | - {:.plus} If quality is suffering, the leaders can redirect strategy to refocus on delivery until the situation improves. 34 | -------------------------------------------------------------------------------- /_organization-culture/core-team.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Core Team 3 | description: Dedicate a team of engineers and architects to the task of uncovering the best transformation path and implementing it along the way. This reduces risk embedded in the transformation while the team gains experience helpful for onboarding the remaining teams later 4 | layout: pattern 5 | --- 6 | 7 | ![Core Team]({{ site.baseurl }}/assets/images/core%20team.png) 8 | 9 | With Vision First in place, the company is now allocating resources to the cloud native transformation and choosing the best teams for leading the initial stages. 10 | 11 | ## In This Context 12 | 13 | Making an existing team or teams responsible for delivering the new cloud native system while still requiring them to work on their regular duties means they will have conflicting priorities—and struggle to deliver either of them at all, much less do it well.This happens very commonly when companies fail to recognize the size and scope ofa cloud native transformation—both the time and resources it will require and the many ways it will impact the organization. Instead, they treat it like another system upgrade added to the backlog of standard tasks. This leads to insufficient resource allocation to the cloud native transformation project and conflicting priorities for the engineers working on it and will almost certainly cause the initiative to stall or simply fail. 14 | 15 | - Teams working on both urgent and important tasks will tend to prioritize urgent tasks first, leading to deprioritization of important tasks such as cloud native transformation. 16 | - Cloud native technologies are new and complex. They require intense time investment for learning and experimentation. 17 | - Some of the cloud native challenges are too difficult for one person to handle. 18 | - A team responsible (and trusted) for delivering a new solution will have full commitment to the solution and later evangelize about it across the organization. 19 | 20 | ## Therefore 21 | 22 | Create a single Core Team of five to eight engineers and architects to lead the transformation.- Team responsibilities will include ownership of the technical vision and architecture and derisking the transformation by running a series of experiments to uncover the best transformation path. 23 | 24 | - Later, the Core Team can use its experience to onboard other teams to the new way of working and to create the Dev Starter Pack materials. 25 | - The team may continue improving the platform after the major parts of the transformation are done. 26 | 27 | ## Consequently 28 | 29 | The Core Team rapidly works through the most challenging parts of the transformation(identifying the best migration path, tools and technologies, and then implementing a minimum viable product version of a platform) and paves the way for the rest of the teams in the company toward successful cloud native adoption. 30 | 31 | {:.plusminus} 32 | - {:.plus} The team is building knowledge and experience in the cloud native area. 33 | - {:.plus} It can use this growing knowledge to adjust the vision and the architecture ofthe applications as it goes. 34 | - {:.plus} Progress is visible and measurable. 35 | -------------------------------------------------------------------------------- /_organization-culture/platform-team.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Platform Team 3 | description: Create a team to be in charge of architecting, building, and running a single, consistent,and stable cloud native platform for use by the entire organization so that developers canfocus on building applications instead of configuring infrastructure 4 | layout: pattern 5 | --- 6 | 7 | ![Platform Team]({{ site.baseurl }}/assets/images/platform%20team.png) 8 | 9 | An enterprise is moving to the cloud and adopting microservices architecture. Many teams are building many different services, and they need extra tools to create the infrastructure to run their pieces of the application. 10 | 11 | ## In This Context 12 | 13 | If there is no single team in charge of creating an official cloud native production platform for the transformation, each team responsible for different microservices will have to build its own platform.This duplicates effort, wastes time, and—most critically—sows conflict when it comes time to deploy. Because each service was built using a different approach on a bespoke platform, they will have conflicting needs and be difficult, if not impossible,to run all on one unified platform. Ops is stuck trying to come up with some kind of Frankenstein solution, but it’s unlikely they will be able to make it work. 14 | 15 | - Different teams will build different solutions if not coordinated. 16 | - Basic cloud is not enough; complex and custom configuration is required. 17 | - Standardization maximizes the possibility of reuse. 18 | - Freedom of choice is needed for finding the best solutions. 19 | - People are creative in finding ways to circumvent the roadblock set by lack of platform, leading to a “shadow IT” effect. 20 | 21 | ## Therefore 22 | 23 | The Platform Team will handle the platform itself—everything between the cloud and the apps (or, to put this in terms of the current technological landscape,Kubernetes and below)—while developers are responsible only for building the applications themselves (again, in the current tech landscape, Kubernetes andabove). 24 | 25 | - Set up a separate team responsible for choosing, building, and configuring a basic set of tools and practices to be used by all of the development teams. 26 | - Build one platform to be used by the entire organization. 27 | - Create a standard and reusable set of tools to simplify work for the devs. 28 | 29 | ## Consequently 30 | 31 | Developers are able to focus on building individual application services, features,and functionality while the Platform Team takes care of running the platform itself. Developers are allowed to introduce custom tools but they will have to support them as part of their own application unless the tools are proven stable and/or requested by other development teams. 32 | 33 | {:.plusminus} 34 | - {:.plus} There is a consistent, reusable, and, above all, stable platform that ensures all services work together seamlessly. 35 | - {:.plus} There is less work for developers: they can just focus on building apps and not worry about the platform they will run on. 36 | - {:.minus} There is also less freedom for developers to choose their tools, although choice is still possible. 37 | --------------------------------------------------------------------------------