Prompts for Cloud Computing and DevOps

15 ready-to-use ChatGPT prompts for cloud computing and DevOps. Fill in the bracketed fields, paste into ChatGPT, and go.

Engineering · 15 prompts

01

Design a Flask Deployment Model on Elastic Beanstalk with Environment and Release Controls

Design a Flask deployment model on Elastic Beanstalk with environment separation, configuration handling, release workflow, observability, and rollback expectations.

You’ll needapp structureaws setupenvironment modelrelease workflowobservability needsconstraints
Prompt
You are a senior cloud computing and devops engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: environment variables and secrets managed through the EB console with no separation between environments, so a staging value can leak into production, deployment done with no health-check-gated rolling process, so a bad release can take down all instances at once, logging and observability left at EB defaults with no application-level tracing, and no rollback plan tested before the first production release actually ships.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Environment separation and secrets handling
- Rolling deployment and health-check gating
- Observability and tracing setup
- Rollback plan tested before go-live
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
02

Automate AWS Provisioning with Terraform Using Environment and State Boundaries

Develop a Terraform-based AWS provisioning setup that includes module boundaries, state handling, and environment separation instead of a one-file infrastructure example.

You’ll needresources neededaws account contextenvironment setupstate strategyteam workflowconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for a Terraform-based AWS provisioning setup.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: a state file stored locally or without locking, risking corruption or conflicting concurrent applies, resources for multiple environments defined in one workspace or state with no isolation so a mistake in staging can touch production, no plan-review step before apply in CI that lets a destructive change slip through, and hardcoded values instead of variables that make the same module unreusable across environments.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including plan-review gating)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
03

Create a Jenkins CI/CD Pipeline for a Node App

Plan a Jenkins pipeline for continuous integration and deployment of a Node.js application.

You’ll needrepo structuredeployment targettest stagesconstraints
Prompt
You are a senior cloud computing and devops architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: pipeline stages that don't fail fast, so a broken build still runs expensive downstream stages before failing, secrets and credentials stored in Jenkins job configuration instead of a scoped credential store, no caching strategy for node_modules that makes every build slower than necessary, and deployment triggered on every merge with no gate for a failed test suite blocking the deploy stage.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
04

Design an EKS Cluster Operating Model for a Production Application

Design an EKS cluster operating model for a production application with networking, access control, workload isolation, scaling expectations, and observability requirements.

You’ll needapplication typeaws account contextnetwork topologyaccess modelworkload profileobservability requirements
Prompt
You are a senior cloud computing and devops engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: IAM roles for service accounts skipped in favor of overly broad node-level permissions that give every pod on a node the same wide access, no resource requests or limits set on workloads so a single pod can starve the cluster during a spike, network policies left wide open by default, letting any pod talk to any other pod across namespace boundaries, and no plan for node or Kubernetes version upgrades, so the cluster silently drifts to an unsupported version.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- IAM and workload-identity design (IRSA)
- Resource requests/limits and workload isolation
- Network policy and namespace boundaries
- Upgrade and version-drift plan
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
05

Create an AWS Lambda Function for S3 Event Processing with Idempotency and Failure Handling

Create a Python AWS Lambda handler for S3-triggered processing that accounts for event shape, retry behavior, idempotency, and downstream failure handling.

You’ll needevent shapeprocessing logicoutput needsdownstream dependenciesidempotency expectationsconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for an S3-triggered Lambda function for event processing.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: no idempotency handling, so S3's at-least-once delivery can process the same event twice and duplicate downstream side effects, Lambda timeout or memory limits not sized for the actual file sizes being processed and causing silent truncation or failure, no dead-letter queue for events that repeatedly fail processing, and the function assuming the S3 event always contains a complete object when large uploads can trigger events before the object is fully written.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including duplicate-event handling)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
06

Monitor Application Health with CloudWatch Metrics, Alarms, and Escalation Signals

Write a CloudWatch-based monitoring setup that turns application health signals into useful metrics, alarms, and actionable alert thresholds rather than noisy notifications.

You’ll needapplication typehealth signalsalerting goalincident response expectationsconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for a CloudWatch-based application health monitoring setup.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: alarms configured on raw metric values with no anomaly or trend detection, missing gradual degradation until it's already an outage, alert thresholds copied from a generic template that don't reflect this application's real baseline, no alarm-to-escalation mapping so a critical alarm and a minor one page the same way, and metrics published with high-cardinality tags that blow up CloudWatch costs without adding real diagnostic value.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including threshold-baseline verification)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
07

Create a Docker Compose Setup for Node and MongoDB with Local Dev Boundaries

Develop a Docker Compose setup for a Node backend and MongoDB that handles service boundaries, environment configuration, volumes, and local developer workflow expectations.

You’ll needservice layoutenv variableslocal dev needsseed or migration flowconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for a Docker Compose setup for a Node backend and MongoDB.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: the MongoDB data volume not actually persisted correctly, so a docker-compose down silently wipes local data, credentials hardcoded into the compose file instead of a gitignored env file, no health check or depends_on ordering so the Node service starts and fails before Mongo is ready, and the compose setup diverging from how the services are actually configured in production, giving false confidence in local testing.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including startup-ordering checks)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
08

Set Up a GitLab CI Pipeline for GCP Deployment

Plan a GitLab CI pipeline to automate deployment to Google Cloud Platform.

You’ll needapplication typegcp targetpipeline stagesconstraints
Prompt
You are a senior cloud computing and devops architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: service account credentials for GCP given project-owner-level permissions instead of scoped to what the pipeline actually needs, pipeline stages with no environment-specific approval gate before a production deploy, no rollback job defined so a bad deploy has to be fixed forward under pressure, and caching or artifacts misconfigured so builds are slower or use stale dependencies.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
09

Create an Ansible Playbook for EC2 Web Servers with Idempotent Server Setup

Create an Ansible playbook for EC2 web servers that covers idempotent package setup, config templating, service management, and inventory assumptions.

You’ll needserver rolepackage setupnumber of instancesos familydeployment assumptionsconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for an Ansible playbook for EC2 web servers.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: tasks that aren't actually idempotent, so re-running the playbook has different effects than the first run, no handling for a partially-failed run leaving the server in an inconsistent state with unclear recovery, secrets templated into files without using Ansible Vault or an external secret source, and no tagging or scoping strategy so a small config change requires re-running the entire playbook against every host.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including idempotency and partial-failure recovery)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
10

Provision an S3 Bucket with Terraform Using Policy, Encryption, and Lifecycle Controls

Write a Terraform configuration for an S3 bucket that includes encryption, versioning, access policy boundaries, lifecycle rules, and environment-safe defaults.

You’ll needbucket purposesecurity rulesenvironment setuplifecycle requirementsaccess modelconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for a Terraform-provisioned S3 bucket with encryption, versioning, and lifecycle controls.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: a bucket policy broader than intended from a wildcard principal or action left in from a copied example, versioning enabled with no lifecycle rule that lets old versions accumulate storage cost indefinitely, encryption specified with the key-management approach left undecided between default and customer-managed KMS, and no plan for what happens to existing objects when encryption is added retroactively.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including policy-scope verification)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
11

Create an Auto-Scaling Strategy on AWS

Design an AWS auto-scaling strategy that matches traffic patterns and availability targets.

You’ll needapplication profiletraffic patternavailability goalsconstraints
Prompt
You are a senior cloud computing and devops architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: scaling policies based on a single metric like CPU that doesn't reflect the actual bottleneck such as memory, queue depth, or connection count, scale-in happening aggressively enough to terminate instances mid-request and drop traffic, no warm-up period before a new instance is considered healthy and gets traffic, and no cost or capacity limits set, so a runaway scaling event can spin up far more capacity than intended.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
12

Configure a Jenkins Pipeline for Azure Web App Deployment

Configure a Jenkins pipeline that builds, tests, and deploys a web app to Azure Web App Service.

You’ll needapp typeazure targetpipeline stagesconstraints
Prompt
You are a senior cloud computing and devops architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: deployment credentials for Azure stored in plaintext Jenkins job parameters instead of a credential store, no staging slot used before swapping into production so every deploy is a direct hit to live traffic, build artifacts not versioned, making it unclear which build is actually running after a rollback, and no health check after deploy to confirm the swap actually succeeded before declaring the pipeline green.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.
13

Design a Helm Chart Release Strategy for a Microservices Platform

Design a Helm chart release strategy for a microservices platform with clear values boundaries, environment overrides, promotion flow, and rollback discipline.

You’ll needservice countcluster contextenvironment promotion flowconfiguration boundariesrollback expectationsconstraints
Prompt
You are a senior cloud computing and devops engineer advising on a real implementation rather than teaching a generic tutorial.

Help with the engineering task below.

Context:
- Goal or task: [goal]
- Stack or environment: [stack]
- Current system or surrounding architecture: [current system]
- Constraints such as security, performance, cost, or compatibility: [constraints]
- Scale, criticality, or production expectations: [criticality]
- Specific questions, failure points, or uncertainty: [pain points]
- Success criteria or desired outcome: [success criteria]

Instructions:
1. Explain the approach in the order the team should actually execute it.
2. Tailor the guidance to the stated stack, constraints, and production expectations.
3. Turn the task into concrete technical decisions, not generic setup advice.
4. Explicitly address the failure modes that actually break this in production: values files structured with no clear separation between environment-specific overrides and shared defaults, causing config drift between environments, chart versioning not tied to application versioning so it's unclear which chart version is actually running in production, rollback assumed to just work without ever being exercised, and secrets templated directly into values files instead of pulled from a secret manager at deploy time.
5. Include validation, rollback, review, or monitoring checkpoints where they materially reduce implementation risk.
6. If important context is missing, make explicit assumptions and continue.

Output format:
- Values structure and environment-override strategy
- Chart-to-application version mapping
- Rollback process tested before relying on it
- Secret handling at deploy time
- Main assumptions and risks

Missing information policy:
Ask up to 2 concise questions only if the stack, required outcome, or operational context is unclear. Otherwise proceed with assumptions.

Quality bar:
- Be concrete and operational.
- Prefer implementation judgment over theory.
- Name the specific failure modes above rather than generic best-practices language.
- Make the advice usable by a team shipping real work.
14

Automate Cloud Database Backups with RDS and S3 plus Retention and Restore Checks

Create an AWS backup workflow for RDS and S3 that covers schedule, retention, encryption, restore verification, and failure visibility.

You’ll needdatabase typebackup scheduleretention needsrestore expectationssecurity constraintsconstraints
Prompt
You are a senior cloud computing and devops engineer.

Produce code or a code scaffold for an RDS-to-S3 cloud database backup workflow.

Context:
- Goal or feature: [goal]
- Stack or language: [stack]
- Inputs and outputs: [inputs and outputs]
- Constraints: [constraints]
- Existing code context: [existing context]
- Integration points or surrounding system: [integration points]
- Acceptance criteria or edge cases: [acceptance criteria]

Instructions:
1. Make the key implementation decisions first, then write code that is correct, readable, and idiomatic for the stated stack.
2. Default to realistic production patterns for common tasks instead of toy scaffolds.
3. Include only the structure that materially helps maintainability, testing, or integration.
4. Explicitly address the failure modes that actually break this in production: backups scheduled with no verification that a restore actually succeeds until the day it's needed, a retention policy that deletes backups before compliance or recovery-point requirements are met, encryption applied to the backup file but not to the transfer path getting it to S3, and no monitoring or alerting for a silently failed backup job.
5. Include validation guidance such as test cases, failure modes, or manual verification steps.
6. Avoid filler placeholders, fake environment variables, and pseudo-code unless the user explicitly wants a sketch.

Output format:
- Implementation approach
- Code
- Validation and test cases (including restore verification)
- Integration notes and assumptions

Missing information policy:
Ask up to 2 concise questions only if the language, framework, integration point, or required behavior is unclear. Otherwise proceed with assumptions.

Quality bar:
- Prefer working simplicity with production realism.
- Avoid placeholder-heavy pseudo-code unless necessary.
- Name the specific failure modes above rather than generic edge-case language.
- Cover meaningful edge cases instead of only the happy path.
15

Design a GitOps Infrastructure Management Approach

Design an approach for managing infrastructure using GitOps with tools like ArgoCD.

You’ll needenvironment countcluster setuprelease goalsconstraints
Prompt
You are a senior cloud computing and devops architect creating a plan for a real engineering initiative.

Create a plan for the task below.

Context:
- Goal: [goal]
- Stack or environment: [stack]
- Current system or baseline: [current system]
- Constraints such as security, latency, budget, or staffing: [constraints]
- Scale, complexity, or production expectations: [scale]
- Risks, current issues, or dependencies: [risks]

Instructions:
1. Recommend a practical technical approach and explain why it fits the context.
2. Break the work into sensible phases, components, or rollout stages.
3. Explicitly address the failure modes that actually derail this kind of initiative: the Git repository holding manifests with no branch-protection or review requirement, so anyone with write access can push straight to production state, drift between the live cluster and the Git source of truth going undetected because auto-sync or drift detection isn't actually enabled, secrets committed to the Git repo instead of using a secret-management integration, and no rollback plan beyond reverting a Git commit, which doesn't account for stateful resources that can't simply be reverted.
4. Include validation, rollback, migration, or monitoring considerations where relevant.
5. Keep the plan realistic for the stated context and avoid architecture theater.

Output format:
- Plan overview
- Recommended approach and tradeoffs
- Implementation phases or rollout path
- Risks, dependencies, and validation checks
- Main assumptions or open questions

Missing information policy:
Ask up to 2 concise questions only if the goal or environment is unclear. Otherwise proceed with assumptions.

Quality bar:
- Make the plan executable.
- Avoid overengineering.
- Name the specific failure modes above rather than generic risk language.
- Show how the plan would survive real deployment pressure.