Devops

Plan a blue-green release with traffic waves, bake windows, capacity checks, rollback triggers, command drafts, and an exposure curve for review.

Plan a canary rollout from traffic steps, bake windows, guardrail limits, and rollback posture with schedule, risk, chart, and export outputs.

Generate OpenTelemetry Collector YAML for OTLP traces, metrics, and logs with pipeline audits, memory guards, batch settings, and endpoint checks.

Plan a secret rotation without pasting the credential, with staged cutover timing, validation gates, risk scoring, and change-record exports.

Generate sitemap XML from same-host URLs or paths, with lastmod handling, crawl-hint controls, dedupe review, and protocol limit checks.

Generate an Apache .htaccess draft from presets and ordered rule sections, then review warnings, counts, and saved JSON before staging changes.

Measure API error-budget burn from status counts or access-log snippets, with SLO projections, status-code policy checks, and burn guardrails.

Estimate API Gateway monthly spend across HTTP, REST, Private REST, and WebSocket traffic with request chunks, transfer, cache, and budget checks.

Estimate AWS Lambda monthly cost from requests, billed duration, memory, provisioned windows, streaming overage, free tier, and editable rates.

Calculate alert noise from classified CSV rows, compare routes with your target, and spot repeat groups, ack delays, and cleanup gaps.

Generate a static Ansible INI inventory from host rows, group variables, and parent groups, with validation warnings and a host ledger.

Generate an Apache vhost draft for static, PHP-FPM, or proxy sites, with TLS settings, required modules, warnings, and activation checks.

Estimate BGP route memory, peer fanout, and churn risk from prefix counts, retained paths, route bytes, update rates, and budgets.

Plan backup repository capacity from data size, retention, change rate, copy tiers, reserves, raw overhead, and budget runway checks.

Estimate backup restore time from logical size, compression, tested throughput, fixed recovery phases, and RTO margin checks.

Size TCP windows from bandwidth and RTT, compare current buffers and stream counts, and spot BDP, overhead, and scaling warnings.

Estimate retained CI artifact storage from build cadence, retention, active refs, compression, caches, reserve, and quota headroom.

Analyze a failed CI job log, rank line-numbered failure clues, group stages, suggest next checks, and mask secret-like snippets before sharing.

Estimate CI runner slots from job volume, occupied minutes, retry load, burst pressure, utilization headroom, and queue-wait targets.

Model cache TTL hit rate from request reuse, fixed or sliding expiry, purge loss, freshness pressure, target TTL, and latency savings.

Build a capacity upgrade brief from utilization growth, threshold timing, lead time, and ranked options with charts and approval-ready notes.

Estimate Ceph usable capacity from node sizes, replica or erasure-code protection, failure-domain reserve, nearfull policy, and PG hints.

Plan TLS certificate renewals from population, validity, lead time, spread, daily capacity, retry reserve, and safety buffer before expiry.

Assess IT change risk from impact, likelihood, readiness, disruption, and evidence, then produce a residual-risk report with gates and chart.

Estimate cloud data transfer spend from monthly volume, cache savings, tiered rates, request add-ons, peak months, and budget variance.

Audit cloud inventory tags, find resources missing required keys or allowed values, and export coverage, gap ledgers, charts, and cleanup queues.

Build cloud-init version 2 network-config YAML for static VM interfaces with CIDR addresses, routes, DNS, MAC matching, and validation warnings.

Estimate container image pull time from size, cache coverage, bandwidth, pull lanes, unpack speed, retries, and rollout optimization levers.

Analyze container scan output in your browser, normalize vulnerability findings, test release gates, and rank fixable packages for remediation.

Parse a Unix cron expression locally, expand the five fields, preview upcoming runs, and flag timezone, macro, day-rule, or dialect risks.

Estimate replica lag catch-up from backlog, write rate, and apply throughput, then compare target windows, retained-log risk, and throttle or boost scenarios.

Estimate DNS resolver cache memory from QPS, hit rate, distinct inserts, TTL, DNSSEC overhead, headroom, and upstream-load charts.

Validate a BIND-style DNS zone file for SOA/NS shape, TTLs, CNAME conflicts, mail readiness, DNSSEC handoff, and normalized output.

Analyze deployment CSV rows into DORA throughput, failure, recovery, and rework signals with warnings, charts, and exportable review tables.

Build a disaster recovery runbook from RTO, RPO, owners, dependencies, recovery steps, validation evidence, and readiness gates for review.

Size a database connection pool across app instances and workers, then check headroom, deploy surge, full-pool risk, and per-holder caps.

Plan a database index rollout with engine-aware SQL, build estimates, lock and replica-lag guardrails, risk scoring, and rollback notes.

Check SQL migration risk before release with static scoring for destructive DDL, blocking indexes, large-table backfills, and rollout notes.

Plan database storage runway from table growth, indexes, logs, backups, replicas, headroom, autoscale ceilings, and cost signals.

Craft a DNS-over-HTTPS wire query, compare GET and POST replay data, tune EDNS and DNSSEC flags, and decode live resolver replies.

Build Docker Compose YAML for a service, then review image or build choices, port exposure, secrets, healthchecks, networks, and volumes.

Check Docker Compose healthchecks for missing probes, weak timing, readiness blockers, restart gaps, and role-based coverage before handoff.

Build a Dockerfile and .dockerignore for Node.js, Python, Go, or Java services with cache mounts, health checks, and hardening warnings.

Check a Dockerfile for risky build and runtime defaults, with weighted findings for base images, secrets, users, package hygiene, and release gates.

Estimate ECMP usable capacity from healthy paths, link rate, demand, hash efficiency, headroom, failure runway, and largest-flow risk.

Convert .env files into YAML, JSON, runtime env, INI, and properties output while checking parsed lines, expansion gaps, and secret-like values.

Check environment variables against a required list and get redacted findings for missing, blank, duplicate, placeholder, and secret-like entries.

Estimate ephemeral port exhaustion from hot-destination connection churn, source address inventory, reuse hold time, reserves, and NAT caps.

Calculate SLO burn rate from current error ratio and remaining budget, then compare runway, alert windows, and mitigation targets.

Calculate how much SLO error budget is used from observed traffic, bad events, burn gates, and runway estimates before release review.

Convert XML in your browser into JSON, JSON Lines, tables, SQL inserts, and formatted XML with record-path checks and schema clues.

Generate a Filebeat Grok pattern from one sample log line, with ECS field mapping, sample-match coverage, and optional ingest pipeline JSON.

Build GitHub Actions cache YAML from your ecosystem, lockfiles, paths, restore keys, and runner notes with review checks before copying.

Generate GitHub Actions matrix workflow YAML with runtime and runner axes, cache choices, include/exclude rows, and review checks.

Estimate GlusterFS usable capacity from brick sizes, replica or dispersed layout, arbiter sizing, stranded space, and recovery headroom.

Calculate a high-availability failover budget from probe cadence, promotion, traffic convergence, client tail, validation, and RTO buffer checks.

Build an HAProxy backend block from server rows, health checks, balance mode, TLS choices, persistence, and review notes before copying.

Convert HCL or Terraform config in your browser into YAML, JSON, and flat key-value views with path ledgers and schema drift checks.

Analyze NGINX, Apache, or ALB access logs in your browser, compare endpoint P95/P99 and 5xx signals, and export SLA findings.

Validate values.yaml against values.schema.json, with Helm-style failure details, schema coverage, hygiene warnings, and a CI command snippet.

Analyze IAM policy JSON for wildcard actions, broad resources, sensitive services, and least-privilege findings before approval.

Review IAM policy JSON for wildcard permissions, broad principals, negated allows, exception claims, and remediation steps before approval.

Convert INI or CFG text in your browser into JSON, YAML, properties, environment-variable text, and normalized INI with parser checks.

Convert storage IOPS, MB/s, Mbps, and GB/day from block size and active hours, then compare ceiling headroom, block pressure, and cloud disk fit.

Calculate incident MTTD, MTTA, MTTC, and MTTR from lifecycle CSV rows, with target breaches, P85 tails, warnings, and stage charts.

Turn incident notes or CSV rows into a sorted timeline, phase handoff, gap chart, and evidence-aware review report for post-incident cleanup.

Plan Kafka topic partitions from throughput, event rate, consumer parallelism, replication footprint, and rounded broker capacity checks.

Generate a Keepalived VRRP config with VIP rows, peer transport, health checks, directive audit, and failover timing before copying.

Convert INI, .properties, and .env text into JSON, YAML, or handoff config with a key ledger, duplicate checks, and local parsing.

Plan a Kubernetes replica ceiling from node allocatable resources, pod requests, surge, PDB, failure drills, zone loss, and pod IP limits.

Generate Kubernetes Deployment YAML with Service routing, probes, resources, security context, rollout policy, and HPA or PDB review warnings.

Find Kubernetes manifests that use APIs removed by a target version, with upgrade blockers, migration queue rows, and replacement snippets.

Analyze Kubernetes event output in your browser, grouping Warning reasons, object hot spots, repeat counts, and timeline bursts from kubectl text or JSON.

Build Kubernetes NetworkPolicy YAML from pod selectors and ingress or egress allow rows, with peer checks, rollout commands, and a flow map.

Check Kubernetes workload YAML for risky securityContext settings, inherited pod defaults, Pod Security blockers, and remediation patch cues.

Check Kubernetes manifests for missing CPU, memory, and storage requests, invalid limits, QoS clues, and scheduler footprint gaps.

Check Kubernetes version skew before a minor upgrade, including API server HA windows, node lag, kubectl fit, staged hops, and blockers.

Calculate LACP bundle capacity after failed links, reserve, and hash efficiency, with headroom, failure tolerance, and single-flow risk.

Model load balancer failover timing from health probes, thresholds, reroute delay, DNS TTL, drain windows, RTO status, and scenarios.

Calculate load balancer pool capacity from backend RPS, weights, health, utilization, growth, and N+ reserve with bottleneck cues.

Calculate a log sampling rate from event volume, event size, storage target, reserves, bursts, and overhead with keep-policy guidance.

Check change schedules for overlapping maintenance windows, blackout hits, owner collisions, and concurrency spikes with review-ready ledgers.

Size a NAT/SNAT pool from public IPs, user fan-out, reserves, growth, and hot-destination pressure with capacity charts and warnings.

Audit an NGINX proxy block for forwarded-header gaps, trust-boundary risks, WebSocket handling, timeout mismatch, and prioritized fixes.

Generate Netplan YAML for a static Ubuntu interface with routes, DNS, MAC matching, MTU options, and validation warnings before host changes.

Generate an NGINX server block for static, PHP-FPM, or proxy hosting with TLS redirects, upstream options, warnings, and deployment checks.

Estimate monthly object storage cost from stored data, object size, requests, retrieval, egress, lifecycle moves, replication, and editable rates.

Estimate retained observability storage from event rate, event size, and retention, then compare compression, replicas, overhead, reserve, and quota.

Estimate monthly observability ingest cost from logs, traces, metrics, collector reduction, indexing, retention, discounts, and growth.

Prepare an on-call handover from incident rows, owners, and escalation notes, then catch hot items, missing actions, and risky async notes.

Generate PXELINUX, iPXE, and GRUB boot menus from CSV-style boot rows, with default checks, fallback entries, and validation review.

Plan a patch window from device count, batch concurrency, install and reboot time, with fit checks, phase timing, slack, and rollback reserve cues.

Calculate a safer PostgreSQL work_mem setting from RAM, concurrency, hash weighting, and spill targets with memory-pressure warnings.

Estimate Prometheus monthly cardinality cost from active series, scrape interval, retention, pricing model, label fan-out, and cleanup savings.

Estimate Prometheus retention storage from active series or samples/sec, with WAL/head reserve, disk headroom checks, and retention.size guidance.

Generate a Prometheus scrape config from target rows, labels, timing, limits, and overrides, then review YAML, ledgers, and audit warnings.

Convert Java .properties text into safer handoff formats, with duplicate-key warnings, path checks, and browser-side parsing.

Plan QoS class bandwidth from a parent rate, then check reserved Mbps, priority share pressure, burst ceilings, and best-effort headroom.

Estimate queue buffer delay from buffer size and link rate, compare full-queue and busy-period latency, and find target buffer limits.

Size queue workers from arrival rate, throughput, backlog, and drain targets, with utilization headroom, cap warnings, and burn-down charts.

Plan RAID usable capacity from drive count, layout, spares, overhead, and reserve with target-fit checks, alternatives, and capacity charts.

Estimate RAID safe IOPS and throughput from drive benchmarks, write mix, spares, controller caps, degraded behavior, and target margin.

Plan a RAID layout with usable capacity, workload headroom, rebuild and URE risk, growth runway, charts, and downloadable reports.

Estimate RAID MTTDL from AFR, rebuild time, URE rate, spares, and fleet size with loss probabilities, mitigation options, and tradeoff charts.

Calculate RAID and RAID-Z usable capacity with spares, fill headroom, chassis fit checks, drive-size ladders, charts, and rebuild risk estimates.

Compare target and measured RPO/RTO windows, flag data-loss or restore-time misses, and estimate extra change or downtime exposure.

Plan rack power density from device watts, rack units, feed rules, growth, and power factor with headroom, heat load, failover, and density cues.

Calculate Redis maxmemory and host RAM in your browser, including key overhead, TTL metadata, replicas, buffers, and RSS headroom.

Calculate a release cutover window with phase timing, rollback reserve, contingency buffer, gate risk, runway scenarios, and charts for change plans.

Build a robots.txt file from crawler sections, path rules, sitemap hints, and imports, then review crawl-policy warnings before publishing.

Validate SAML metadata XML for entity IDs, SP or IdP roles, endpoint policy, certificate expiry, signature presence, and import blockers.

Calculate SLA availability from downtime and maintenance rules, then compare remaining budget, burn rate, breach risk, and period checkpoints.

Generate Prometheus SLO burn-rate alert YAML with multi-window tiers, budget thresholds, routing labels, a chart, and review tables.

Estimate SNMP polling pressure from devices, OIDs, intervals, retries, SNMPv3 overhead, MTU limits, and poller capacity checks.

Match a TLS leaf certificate to a candidate issuer CA, then review signature proof, DN alignment, CA status, expiry risk, and trust score.

Match a TLS certificate to its CSR or RSA private key in your browser with SPKI pins, chain warnings, encrypted-key support, and exports.

Estimate TLS handshake CPU load from request rate, connection reuse, full versus resumed costs, surge peaks, core budgets, charts, and warnings.

Trace a live TLS endpoint, check the negotiated protocol and certificate chain, and separate DNS, TCP, and TLS timing problems.

Turn TOML into target config formats with parse checks, key-path ledgers, type previews, and schema sketches for safer migrations.

Generate browser-local installer terminal output with package-manager presets, seeded replays, network jitter, progress traces, and exportable logs.

Review Terraform plan JSON or text before apply, with destructive-change gates, drift signals, output-change checks, and provider impact charts.

Check pasted Terraform variable blocks for risky defaults, secret-like values, type mismatches, nullable behavior, and prioritized remediation rows.

Calculate thread pool saturation from active workers, queue depth, arrival rate, task time, wait percentiles, and capacity scenarios.

Calculate uptime budgets from SLA targets, downtime, maintenance policy, and elapsed period with burn pace, target status, charts, and exports.

Size VM datastore capacity across thin disks, snapshots, swap, growth, reserves, and raw protection overhead with runway checks.

Plan safe VM capacity for a virtualization cluster with CPU, memory, N+ failover, maintenance reserve, growth runway, and large-VM checks.

Calculate vulnerability remediation SLA due dates from CSV rows, flag overdue or due-soon findings, and build owner-ready queues.

Check domain registration data with RDAP-first lookup, WHOIS fallback, renewal timing, status clues, nameservers, contacts, and JSON.

Build a wget command for downloads, API fetches, FTP pulls, or site mirrors with shell-aware quoting, import parsing, exports, and safety warnings.

Convert YAML into JSON, env, INI, properties, and path tables with local parsing, document checks, schema review, and scalar-only exports.

Plan ZFS usable capacity for pool builds from vdev layout, disk size, RAID-Z padding, OpenZFS slop, reserve, and target-fit paths.