Devops

Plan canary traffic steps and observation windows with guardrail thresholds, exposure estimates and platform-aware rollback warnings.

Build an Apache .htaccess draft with routing, caching, headers, and access rules plus warnings to resolve before server testing.

Convert a supported .htaccess subset into a reviewable NGINX draft with explicit warnings for unsupported or non-equivalent directives.

Measure API error-budget burn from status counts or access logs, project the compliance window, and spot policy-breaking failure rates.

Estimate monthly Amazon API Gateway charges across API families with request chunking, transfer costs and private endpoint budget context.

Estimate monthly AWS Lambda Functions cost across requests, GB-seconds, provisioned capacity and optional meters with editable regional rates.

Measure alert noise from classified CSV rows, compare it with your target, and isolate repeated alert-route groups without uploading data.

Generate a static Ansible INI or YAML inventory from host rows and groups with checks for value typing, duplicate variables, and secrets.

Draft an Apache virtual host for static files, PHP-FPM applications, or reverse proxies with TLS safeguards and activation checks.

Estimate BGP route-state memory and update pressure from prefix and peer counts, retained paths and route bytes, with budget guardrails.

Plan backup repository capacity from retention and change rate with growth assumptions, copy tiers, operational reserves and raw storage overhead.

Estimate a backup restore window from data size and tested throughput with compression and recovery phases, then check the RTO margin.

Calculate bandwidth-delay product and per-stream TCP window targets from path rate and RTT, then compare current buffers and stream counts.

Plan a blue-green deployment with timed traffic shifts and health gates, then review exposure and rollback triggers with route-specific command drafts.

Estimate retained CI artifact storage and forecast growth against a quota using build cadence plus retention, cache, and reserve assumptions.

Find actionable clues in a failed CI log, map them to pipeline stages, and mask common secret patterns before sharing the evidence.

Estimate CI runner slots from workload minutes and peak demand, then check utilization headroom and queue-clear time against platform caps and retry load.

Model hit rate for fixed or sliding cache TTLs and compare target reachability with origin load, latency savings, and freshness pressure.

Build a capacity upgrade brief from utilization and compounded growth, then compare threshold runway, lead time and ranked upgrade options.

Estimate recovery-safe Ceph usable capacity for replicated or erasure-coded pools with failure-domain reserve, fullness limits and PG guidance.

Plan certificate renewal capacity across a safe pre-expiry window with retry reserve and daily load, then check spread and deadline slack.

Assess an IT change with weighted impact and readiness evidence to produce a residual-risk tier, approval route and gate-closing actions.

Estimate cloud egress spend from measured traffic and a marginal rate card with verified reductions, peak-month stress testing, and budget variance.

Audit cloud inventory tags against required keys and allowed values, measure whole-resource coverage, and rank the gaps that need cleanup.

Build cloud-init version 2 YAML for a static VM interface, with CIDR and route validation plus warnings for risky boot assumptions.

Estimate container image pull time across rollout waves from cache coverage and changed layers, with bandwidth, unpack and retry assumptions.

Normalize container scan reports, apply critical and high release limits, and rank fixable findings for a focused remediation queue.

Parse five-field Unix cron expressions, preview upcoming runs in local time or UTC, and flag dialect, day-matching, and timezone risks.

Estimate whether a database replica can drain its backlog within a target window, with retained-log risk and throttle or apply-boost scenarios.

Estimate DNS resolver cache memory from insert churn and TTL, then compare budget headroom with upstream QPS and hit-versus-miss latency.

Validate a DNS zone file before import, uncover authority and TTL conflicts, and inspect expanded records without uploading the source.

Analyze deployment records across five DORA metrics with transparent formulas and adjustable guardrails, plus warnings when recovery evidence is missing.

Build a disaster recovery runbook around RTO and RPO goals, accountable recovery steps and evidence-based readiness gates for owner review.

Size database connection pools across replicas and workers while checking reserve-aware headroom, rollout surge risk and per-holder caps.

Plan a database index rollout with engine-aware SQL and build estimates, then review risk and guardrails for validation and rollback.

Check SQL migration risk before release with engine and table context, exposing destructive changes plus lock hazards, rewrites and backfills.

Forecast database storage runway from projected data growth, then include operational overhead and estimate threshold dates and monthly cost.

Build an exact DNS-over-HTTPS query packet, inspect its wire fields and EDNS options, then replay it with GET or POST against a resolver.

Build single-service Docker Compose YAML with safer network and secret defaults plus storage, health-check and restart-policy review.

Check Docker Compose healthchecks for missing commands, timing risks, blocked readiness dependencies, and role-based coverage before release.

Build a Dockerfile and .dockerignore for Node.js, Python, Go or Java using multi-stage patterns plus cache mounts and hardening checks.

Check a Dockerfile for risky base images, embedded secrets, broad copies, root users, package residue, and missing runtime safeguards.

Estimate ECMP route capacity from healthy paths and hash efficiency, then test reserve headroom plus member-failure and single-flow limits.

Convert ENV text into common configuration formats with controlled expansion, duplicate-key handling and secret-like value checks before deployment.

Compare required environment variables with ENV, JSON, or YAML inventories and find missing, blank, placeholder, duplicate, or extra entries.

Estimate ephemeral port pressure for a hot destination from connection churn, held time and source inventory with reserve and capacity thresholds.

Calculate SLO error-budget burn rate and compare page or ticket thresholds, then estimate runway from the budget that remains.

Calculate SLO error-budget use from observed traffic, compare burn and policy gates, and estimate runway before a release decision.

Turn XML into structured JSON or record-based tables with local parsing, record-path selection, whitespace controls, and schema checks.

Turn one representative log line into a Filebeat-ready Grok pattern with ECS-aware fields, local match checks, and optional ingest pipeline JSON.

Generate GitHub Actions cache YAML from ecosystem and lockfile choices, with ordered restore keys and security checks before you commit it.

Build a GitHub Actions matrix workflow with accurate job expansion, exception rules, cache choices, and review checks before you commit.

Plan GlusterFS usable capacity from brick sizes and protected-set layout while checking stranded space, arbiter needs, and recovery headroom.

Calculate a serial HA failover budget, compare every recovery phase with an RTO and safety reserve, and identify the longest delay.

Build an HAProxy backend block from server rows with health checks and TLS trust choices, then review capacity limits and deployment warnings.

Convert Terraform-style HCL into JSON or flat configuration text, with path and type checks that expose lossy handoffs before reuse.

Analyze NGINX, Apache, or ALB access logs locally for endpoint P95 and 5xx rates with clear parse-gap evidence and SLA findings.

Validate values.yaml against values.schema.json, separate blocking schema errors from hygiene warnings, and inspect root-key coverage before CI.

Review AWS IAM policy JSON for wildcard breadth, privilege paths, and policy-shape issues before validating effective access in AWS.

Check AWS IAM policy JSON for wildcard permissions and broad PassRole exposure, then rank the statements that need least-privilege remediation.

Convert INI or CFG into structured or flat configuration text with explicit duplicate handling, type inference, and skipped-line review.

Convert IOPS, throughput, and daily volume from I/O size and active hours, then check reserve-adjusted ceilings and cloud disk limits.

Calculate incident MTTx metrics from lifecycle CSV rows, then compare means and tail percentiles with strict acknowledgement and recovery targets.

Turn incident notes into a sorted chronology with phase coverage, evidence gaps and response-cadence checks for a review-ready handoff report.

Plan a Kafka topic partition count from throughput and consumer parallelism, then check broker spread and keying risk before rollout.

Generate a Keepalived VRRP configuration for one node with validated peer settings, health tracking, and an estimated failover interval.

Convert INI, Java properties, and dotenv text into reviewable structured or line-based configuration with path and duplicate checks.

Estimate a rollout-safe Kubernetes replica ceiling from allocatable resources and pod requests, then test node loss and disruption limits.

Build Kubernetes Deployment YAML with optional Service and policy resources, plus checks for rollout, probes, resources, and security choices.

Check Kubernetes manifests for APIs removed by a target release, distinguish blockers from later cleanup, and review documented migration cues.

Turn Kubernetes Event text or JSON into a repeat-aware timeline with warning concentration, reason groups, and object hot spots.

Build Kubernetes NetworkPolicy YAML from pod labels and allow rules with selector checks, rollout guidance, and security review warnings.

Check Kubernetes workload YAML for inherited security contexts, Pod Security gaps, weighted findings, and a reviewable hardening patch.

Check Kubernetes manifests for missing resource requests and invalid limits, with QoS clues and scheduler-footprint evidence before rollout.

Check Kubernetes component version skew for the next minor upgrade hop, with compatibility windows, blockers and an ordered rollout plan.

Calculate usable LACP bundle capacity after failed links, reserve, and hash-efficiency discounts while checking aggregate and single-flow headroom.

Estimate user-visible load balancer failover time across health checks, routing changes, DNS cache exposure, and an RTO target.

Estimate weighted load balancer pool capacity from measured backend RPS and routing weights, with bottleneck and N+ failure-reserve checks.

Calculate a log sampling rate that fits a daily storage target while reserving critical records and accounting for bursts and index overhead.

Check maintenance schedules for time overlap, shared services or owners, blackout conflicts, guard-buffer near misses, and concurrency spikes.

Size a NAT or SNAT public address pool from client sessions, planning reserve and hot-destination demand with headroom and failure checks.

Audit an NGINX proxy block for unsafe forwarded headers and trust-boundary gaps with checks for WebSocket, timeout and upstream TLS risks.

Build Netplan YAML for Ubuntu static interfaces with CIDR addresses, DNS, routes, and warnings for gateway or priority mistakes.

Generate an NGINX server block for static sites, PHP-FPM apps, or reverse proxies with TLS routing plus safety and activation checks.

Calculate OSPF interface cost from reference and link bandwidth, compare a manual override, and reveal fast links that collapse to cost 1.

Estimate monthly object storage cost from capacity and request volume with retrieval, egress, lifecycle and editable provider rate assumptions.

Estimate observability storage from event volume and retention with compression, replica copies and reserve plus optional quota headroom.

Estimate monthly observability ingest cost from measured telemetry and model collector reduction across vendor meters with retention discounts and growth.

Prepare an on-call handover with normalized incident rows, ownership checks, readiness rules, and warnings for risky or incomplete transfers.

Generate OpenTelemetry Collector YAML for OTLP pipelines with memory and batch controls, endpoint checks, and rollout warnings.

Build matched PXELINUX, iPXE and GRUB boot menus from one entry list with default and fallback checks for safer network-boot handoffs.

Estimate a sequential patch window from fleet size and concurrency, then test phase timing and reserves against fit, slack and rollback needs.

Size PostgreSQL work_mem from server RAM and active query demand with hash weighting, safety margins and scoped spill guidance.

Estimate Prometheus monthly cost from active series and retention, then model cleanup savings and growth with editable managed or self-hosted rates.

Estimate Prometheus local storage from series or sample rate, then account for retention and compression plus WAL reserve and disk budget.

Build Prometheus scrape YAML from target rows and labels with timing, grouping, limits and validation cues to review before a live reload.

Convert Java properties into structured or line-based configuration with decoded escapes, scalar handling, and clear duplicate-key checks.

Allocate a QoS parent rate across traffic classes and check reserved bandwidth, best-effort headroom, burst ceilings and priority pressure.

Calculate queueing delay from buffer depth and bottleneck rate, then compare occupancy and target buffer size with optional BDP context.

Size a queue worker pool from busy-period arrivals, measured throughput, backlog drain time, utilization headroom, and worker limits.

Calculate planned RAID capacity after spares, protection, overhead, and reserve, then check target fit, drive size, and bay count.

Estimate RAID IOPS and throughput from drive benchmarks and workload mix, with write penalties, reserve, controller caps, and degraded scenarios.

Compare RAID capacity, workload headroom, rebuild exposure, recovery pressure, and three-year growth under one set of assumptions.

Estimate RAID MTTDL and fleet loss from AFR, rebuild exposure, spares, correlation, and URE pressure with comparable mitigation scenarios.

Plan RAID and RAID-Z capacity from drive geometry, parity, hot spares, fill headroom, metadata reserve, and physical chassis limits.

Compare RPO and RTO targets with measured recovery evidence, flag data-loss and restore-time gaps, and estimate added change or downtime exposure.

Plan rack power density from device loads and feed limits, with failover headroom, heat output, occupancy, and watts-per-U guidance.

Size Redis maxmemory, per-process host RAM, and replica capacity from measured key costs, growth headroom, buffers, and shard plans.

Budget a release cutover against its maintenance window, preserving rollback time while safely testing contingency and gate margin.

Generate a robots.txt policy with crawler-specific path rules and sitemap declarations plus import checks and warnings before publication.

Review SAML metadata XML for import blockers across roles and endpoints with local checks for certificate dates, refresh validity and signature presence.

Calculate SLA availability and downtime allowance with planned-maintenance policy, then check budget use, burn rate and breach projection.

Generate multi-window Prometheus SLO burn-rate alerts with budget math and routing labels, then review thresholds before loading the YAML.

Estimate SNMP polling pressure from devices and OIDs with interval and packing effects plus security, MTU and per-poller capacity checks.

Match a TLS leaf certificate to a candidate issuer with signature verification, CA checks, expiry horizons, and policy-based review guidance.

Compare a TLS certificate with a CSR or RSA private key in your browser, using exact SHA-256 SPKI identity checks without uploading secrets.

Plan a secret rotation with staged cutover timing and consumer validation, rollback gates, and a transparent risk score without entering credentials.

Turn same-host URLs or paths into sitemap XML with normalization and exclusion checks, then review protocol limits before publishing.

Estimate TLS handshake CPU demand from request rate, connection reuse, full and resumed costs, surge traffic, and the available core budget.

Trace a live TLS handshake to review protocol and cipher, certificate identity and trust, plus DNS-to-negotiation timing from one remote probe.

Convert TOML into structured or flat configuration text with parse checks and warnings when the target cannot preserve types or nesting.

Build a repeatable installer terminal rehearsal with synthetic timing and warning lines, package-manager vocabulary, and a seeded transcript.

Analyze Terraform plan JSON or text before apply, flag destructive changes and drift, and rank resources by review risk without uploading plan data.

Review Terraform variable blocks for unsafe defaults and secret-like values, then prioritize type mismatches, version conflicts and fixes.

Estimate thread pool saturation from arrival rate and task time plus queue pressure, with wait-target checks, headroom warnings and capacity scenarios.

Calculate allowed downtime and budget use from an SLA or SLO target, with burn pace and projected availability under a chosen maintenance policy.

Estimate spike-safe VM datastore capacity with provisioning and snapshot pressure plus reserves, protection overhead and current-pool runway.

Estimate safe virtualization host capacity after failure and maintenance reserves, including growth headroom and large-VM placement checks.

Turn vulnerability backlog CSV into policy-based due dates and owner-ready remediation priorities with overdue, due-soon and compliance signals.

Check domain registration data through RDAP with WHOIS fallback, then review expiry timing, nameservers and evidence coverage for follow-up.

Build a shell-quoted wget command for single downloads or recursive retrieval, with import parsing and warnings for risky options.

Convert YAML locally into structured JSON or normalized YAML and flat configuration text, with path and type checks that expose lossy transformations.

Compare two YAML documents as parsed data with schema-aware scalar types and sequence matching, then review path-level changes and ignored paths.

Calculate planned ZFS capacity after vdev protection, RAID-Z padding and operating reserves before choosing disks or comparing topologies.