Prompts for Systems Engineering

15 ready-to-use ChatGPT prompts for systems engineering. Fill in the bracketed fields, paste into ChatGPT, and go.

Engineering · 15 prompts

01

Automate Linux User Account Management

Write a script to automate creating and managing Linux user accounts.

You’ll needaccount rulesserver contextpermissions modelconstraints
Prompt
You are a senior systems engineer.

Produce code or a code scaffold for a Linux user account management automation script.

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: accounts created with default or predictable passwords never forced to change on first login, group membership and sudo access granted broadly instead of scoped per role, no deprovisioning path so accounts for departed users linger indefinitely, and inconsistent home-directory or permission setup that creates a privilege-escalation surface across accounts.
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 deprovisioning 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.
02

Plan a Network Infrastructure Upgrade

Design a plan for upgrading a medium-sized company's network to handle more traffic.

You’ll needcurrent networkgrowth projectionsavailability goalsconstraints
Prompt
You are a senior systems engineering 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: capacity planned for current traffic with no margin for the growth that prompted the upgrade in the first place, a cutover plan that requires full downtime instead of a staged migration, no rollback path if new hardware or configuration causes an unexpected outage, and legacy devices or protocols still in use that aren't compatible with the new infrastructure, discovered only during cutover.
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.
03

Create a Server Health Monitoring System

Develop a monitoring system for server health and uptime using Prometheus and Grafana.

You’ll needserver estatecritical metricsalerting goalsconstraints
Prompt
You are a senior systems engineering 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: dashboards built before alerting rules, so problems are visible only to someone actively looking rather than being pushed to the right person, metric retention set too short to do any real trend analysis or capacity planning, alert thresholds copied from generic examples instead of derived from this environment's real baseline, and no on-call ownership defined for who actually responds when an alert fires.
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

Automate System Backups and Disaster Recovery Tasks

Create a script to automate backups and disaster recovery operations for critical systems.

You’ll needsystem scopebackup targetrecovery goalsconstraints
Prompt
You are a senior systems engineer.

Produce code or a code scaffold for a system backup and disaster recovery automation script.

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 run on schedule but never actually test-restored, so a 'successful' job can still be unusable in a real recovery, no offsite or geographically separate copy, so a site-level disaster takes out the backups along with the primary system, a restore procedure undocumented or dependent on one person's tribal knowledge, and a retention policy that doesn't match the actual recovery-point objective the business needs.
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.
05

Design a Fault-Tolerant Data Center Network Topology

Design a network topology for a large-scale data center with redundancy and fault tolerance.

You’ll needcapacity needsredundancy goalstraffic profileconstraints
Prompt
You are a senior systems engineering 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: redundancy designed at the device level such as dual switches but with a single shared uplink or power source that defeats the point, no plan for how failover is actually tested rather than just assumed to work, spanning-tree or routing convergence time not accounted for so a failover still causes a real outage window, and capacity headroom not planned for a single rack or zone failure during peak load.
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.
06

Manage System Configurations with Ansible or Puppet

Develop a method for managing system configurations with a configuration management tool.

You’ll needserver estatetool choicechange cadenceconstraints
Prompt
You are a senior systems engineering 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: configuration drift between what the tool declares and what's actually running because manual changes are still made directly on servers, no idempotency verification so re-running configuration has different effects on different hosts, secrets managed in plaintext within the configuration repository, and no staged rollout, so a bad configuration change is applied to the entire fleet before anyone notices.
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.
07

Design a Centralized Logging Operating Model with Ingestion, Retention, and Ownership Rules

Design a centralized logging operating model with ingestion boundaries, retention policy, alerting expectations, and clear ownership instead of a generic ELK setup checklist.

You’ll needserver countlog typesretention needsalerting expectationsownership modelconstraints
Prompt
You are a senior systems 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: a retention policy set uniformly across log types instead of matched to what compliance or debugging actually requires, an ingestion pipeline with no back-pressure handling, so a log volume spike from one noisy service can drop or delay logs from everything else, no ownership assigned for which team monitors and acts on which log streams, and sensitive data such as credentials or PII flowing into logs with no redaction step before storage.
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:
- Ingestion pipeline and back-pressure handling
- Retention policy matched per log type
- Ownership and alerting responsibility
- Redaction and sensitive-data handling
- 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.
08

Design a High-Availability Web Application Hosting Solution

Design a scalable hosting solution for a web app with high availability and fault tolerance.

You’ll needapplication profiletraffic needsuptime targetconstraints
Prompt
You are a senior systems engineering 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: high availability designed at the compute layer but the database left as a single point of failure, health checks that only verify the process is running and not that it can actually serve a real request, failover tested once at launch and never re-verified after subsequent changes, and no plan for split-brain if multiple instances briefly believe they're each the primary.
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

Track System Performance Metrics with a Script

Develop a script to track CPU, memory, and disk usage on a system.

You’ll needos typemetrics targetsampling needsconstraints
Prompt
You are a senior systems engineer.

Produce code or a code scaffold for a system performance metrics tracking script.

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: metrics sampled at an interval too coarse to catch short-lived spikes that actually cause user-facing issues, disk and memory metrics reported without distinguishing cache or buffer usage from genuine pressure, no baseline established so a 'high' reading has no reference point to judge against, and the script itself consuming enough resources under load to skew the very metrics it's trying to measure.
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 baseline comparison)
- 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

Create a Dynamic Server Resource Scaling Plan

Create a plan for scaling server resources dynamically based on user load.

You’ll needapplication profiletraffic patterninfra environmentconstraints
Prompt
You are a senior systems engineering 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 triggers based on a single resource metric that doesn't reflect the actual user-facing bottleneck, no cool-down period between scaling actions that causes rapid flapping up and down, no cost ceiling defined so a runaway scaling event can become a runaway bill, and scale-down logic that can terminate an instance mid-request instead of draining connections first.
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.
11

Automate Patch Management Across Servers

Write a script for automating patch management and software updates across servers.

You’ll needserver estateos familymaintenance windowsconstraints
Prompt
You are a senior systems engineer.

Produce code or a code scaffold for a cross-server patch management automation script.

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: patches pushed to all servers simultaneously with no staged rollout, so a bad patch takes down the whole fleet at once, no pre-patch snapshot or rollback path if an update breaks a running service, reboot requirements not tracked, leaving servers silently running unpatched in memory despite showing as updated, and patch success measured by package-manager exit code alone with no service-health check afterward.
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 staged rollout and post-patch health 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.
12

Design an Automated Disaster Recovery Testing Approach

Design an approach for automated disaster recovery testing in a cloud environment.

You’ll needsystem criticalityrecovery goalscloud setupconstraints
Prompt
You are a senior systems engineering 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: DR tests scheduled but scoped to only the easy parts of the system, leaving the actual hard dependencies untested, tests run against a sanitized or simplified environment that doesn't match production's real complexity, no measurement of actual recovery time against the target RTO/RPO, and test results not fed back into fixing the gaps they reveal, so the same failures repeat in the next test.
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

Secure Internal Communication Systems

Develop a strategy for securing internal company communication systems with encryption and VPNs.

You’ll needcommunication channelssecurity goalsuser baseconstraints
Prompt
You are a senior systems engineering 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: encryption applied to communication in transit but internal trust boundaries left flat, so a compromised internal system can still access everything, VPN or internal network access provisioned once and never reviewed or revoked as roles change, key or certificate rotation with no automated process, relying on someone remembering to do it manually, and no distinction between the security requirements of routine internal traffic and sensitive or regulated communications.
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.
14

Design a VMware ESXi VM Operating Model for Production Workloads

Design a VMware ESXi VM operating model for production workloads covering provisioning, resource allocation, storage and network setup, and operational guardrails.

You’ll needhost environmentworkload typesstorage and network contextavailability expectationsoperational modelconstraints
Prompt
You are a senior systems 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: VMs provisioned with resource reservations that oversubscribe the host, so contention only shows up under real load, no separation between management, vMotion, and VM traffic on the network, creating both a performance and security risk, storage multipathing configured but never actually tested by simulating a path failure, and snapshot usage left unmanaged, silently consuming datastore space until it causes an outage.
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:
- Resource allocation and oversubscription limits
- Network traffic separation (management, vMotion, VM)
- Storage multipathing verification
- Snapshot lifecycle management
- 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.
15

Monitor and Alert on Resource Thresholds

Write a script to monitor CPU, memory, and disk space and alert when thresholds are exceeded.

You’ll needserver typethreshold rulesalert channelconstraints
Prompt
You are a senior systems engineer.

Produce code or a code scaffold for a resource-threshold monitoring and alerting script.

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: static thresholds that don't account for a system's normal daily or weekly usage pattern, causing alerts to fire constantly during expected peaks, no distinction between a sustained resource problem and a brief transient spike, alert routing with no severity tiering so a near-capacity warning pages the same as an already-critical outage, and no suppression or dedup logic, so one ongoing issue generates a flood of repeated alerts.
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 transient-vs-sustained 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.