Devops

Plan a blue-green release schedule with traffic waves, bake windows, capacity warnings, rollback triggers, command drafts, and exposure estimates.

Plan a canary rollout with traffic steps, bake windows, guardrail thresholds, rollback actions, risk notes, charts, and exports.

Generate OpenTelemetry Collector YAML for OTLP traces, metrics, and logs with pipeline ledgers, memory guards, batching, and endpoint checks.

Plan a secret rotation with staged cutover timing, validation gates, risk scoring, and exportable change evidence without pasting credentials.

Generate sitemap XML from same-host URLs or paths, normalize lastmod and crawl hints, review exclusions, and catch protocol limits before publishing.

Build an Apache .htaccess draft for redirects, headers, caching, CORS, and access rules with warnings and copy-ready output before staging.

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 review warnings before playbook use.

Generate an Apache vhost draft for static, PHP-FPM, or reverse-proxy sites, with TLS choices, module checks, and activation steps.

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 service utilization, growth, threshold timing, lead time, and ranked options with charts and approval 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 an IT change from impact, likelihood, disruption, rollback, validation, monitoring, and communications to produce a residual-risk report.

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 YAML for static VM NICs, with CIDR, routes, DNS, MAC matching, and validation warnings before boot.

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 in your browser, expand five fields, preview upcoming runs, and catch timezone, macro, day-rule, and 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 DNS zone file before import, catching SOA/NS gaps, TTL risks, CNAME conflicts, mail-policy warnings, and normalized records.

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 checks, 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-specific SQL, build-time estimates, risk scoring, guardrails, and rollback-ready runbook notes.

Check SQL migration risk before release, flag destructive DDL, blocking index builds, large-table backfills, and rollout actions.

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

Craft a DNS-over-HTTPS query packet, compare GET or POST replay data, inspect EDNS/DNSSEC flags, and decode live resolver replies.

Build Docker Compose YAML for one service, with image/build choices, port exposure, .env secret references, healthchecks, networks, and review notes.

Check a Docker Compose file for missing or weak healthchecks, readiness-gate blockers, restart gaps, and role-based coverage before release.

Build a Dockerfile and .dockerignore for Node.js, Python, Go, or Java services, with cache mounts, healthchecks, and hardening review notes.

Check a Dockerfile for risky defaults, line-level findings, and release-gate warnings covering base images, secrets, users, packages, and healthchecks.

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

Convert .env files to YAML, JSON, runtime env, INI, and properties output with parser traces, expansion checks, and secret-like value review.

Audit required environment variables against pasted or uploaded inventories with redacted missing, blank, placeholder, duplicate, and secret-like findings.

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 into JSON, JSON Lines, tables, SQL inserts, and formatted XML with local parsing, record-path checks, and schema review.

Turn one representative log line into a Filebeat-ready Grok pattern with ECS field mapping, sample-match checks, and optional ingest pipeline JSON.

Generate GitHub Actions cache YAML from ecosystem presets, lockfiles, restore keys, runner notes, and review checks before copying.

Build a GitHub Actions matrix workflow with runner and runtime axes, cache choices, exception rows, and review checks before committing.

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 with health checks, TLS options, persistence notes, review warnings, and copy-ready output.

Convert Terraform-style HCL into JSON, YAML, env, INI, properties, and path ledgers with browser-local parsing 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, find Helm-style schema failures, coverage gaps, hygiene warnings, and a CI snippet.

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

Check IAM policy JSON for wildcard actions, resources, principals, negated allows, and PassRole exposure with ranked remediation evidence.

Convert INI or CFG text into JSON, YAML, env text, Java properties, and normalized INI with duplicate-key, skipped-line, and type checks.

Convert IOPS, throughput, and daily data volume from block size and active hours, then compare reserve-adjusted ceilings 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 into a sorted timeline with phase coverage, long-gap checks, evidence warnings, and a Markdown-ready review report.

Plan Kafka topic partitions from throughput, event rate, consumer parallelism, replication footprint, broker balance, and keying warnings.

Generate a Keepalived VRRP config with VIP rows, unicast or multicast peer settings, health tracking, directive audits, and failover timing.

Convert INI, .properties, or .env text into JSON, YAML, properties, INI, or dotenv output with a key ledger and duplicate checks.

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 settings, rollout policy, and HPA or PDB review warnings.

Check Kubernetes manifests for API versions removed by a target release, with blocker counts, migration queues, and replacement cues.

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 labels and allow rows, with peer syntax checks, rollout commands, review warnings, and a flow map.

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

Check Kubernetes manifests for missing CPU, memory, and ephemeral-storage requests, limit mismatches, 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.

Estimate load balancer failover time from probe intervals, thresholds, reroute delay, DNS TTL, drain windows, and RTO scenario pressure.

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

Calculate the log sampling rate needed to fit a daily storage target, with event-size math, protected reserves, burst planning, and keep-policy cues.

Check maintenance schedules for overlapping windows, blackout hits, owner or dependency collisions, and concurrency spikes in review-ready ledgers.

Size a NAT or SNAT pool from public IPs, sessions, reserve, growth, and hot-destination pressure with capacity warnings and charts.

Check an NGINX proxy block for forwarded-header gaps, spoofed-client risks, WebSocket handling, timeout mismatches, and fix order.

Build Netplan YAML for Ubuntu static interfaces with CIDR addresses, DNS, routes, MAC matching, MTU checks, and review warnings.

Generate an NGINX server block for static, PHP-FPM, or proxy sites with TLS redirects, upstream checks, HSTS cues, and deploy notes.

Estimate monthly object storage cost from average capacity, object size, requests, retrieval, egress, lifecycle exposure, and editable rate cards.

Calculate retained observability storage from event rate, event size, retention, compression, replicas, overhead, reserve, and quota headroom.

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

Prepare an on-call handover from incident rows, owners, and escalation notes with hot-item, missing-action, and async-risk warnings.

Generate PXELINUX, iPXE, and GRUB boot menus from boot rows, with default-entry checks, fallbacks, validation notes, and JSON output.

Estimate a patch window from device count, batch size, install and reboot time, with slack, phase timing, canary, and rollback cues.

Size PostgreSQL work_mem from RAM, active query slots, hash weighting, and spill evidence, with safer global defaults and override hints.

Estimate Prometheus cardinality cost from active series, label fan-out, retention, and pricing assumptions with cleanup savings and PromQL checks.

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

Generate Prometheus scrape YAML from targets, labels, timing, and limits, then check grouping, overrides, and audit warnings before reload.

Convert Java .properties text into JSON, YAML, INI, env, and normalized properties output with duplicate-key, path, and type checks.

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

Calculate queue buffer delay from buffer size and link rate, then compare full-queue latency, occupancy, BDP, and target limits.

Plan queue worker counts from arrival rate, throughput, backlog, drain time, and utilization headroom with cap and delay warnings.

Plan RAID usable capacity from drive count, drive size, layout, hot spares, overhead, and reserve with target-fit and sizing-path checks.

Estimate RAID IOPS and throughput from drive benchmarks, read-write mix, write locality, rebuild reserve, controller caps, and degraded targets.

Plan a RAID layout with plannable capacity, workload headroom, rebuild exposure, URE pressure, growth runway, charts, and JSON reports.

Estimate RAID MTTDL from AFR, rebuild time, URE rate, spares, correlation, and fleet size with loss probabilities and mitigation checks.

Plan RAID and RAID-Z usable capacity from layout, drive size, hot spares, fill headroom, chassis bays, and rebuild-risk assumptions.

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

Model rack power density from device watts, feed limits, growth, and power factor with failover headroom, heat load, and W/U cues.

Size Redis maxmemory and host RAM from key counts, value sizes, TTL overhead, replicas, buffers, RSS headroom, and shard-fit warnings.

Plan a release cutover window from phase minutes, contingency, rollback reserve, safety floor, gate margin, runway scenarios, and charts.

Generate a robots.txt draft with crawler groups, path rules, sitemap hints, import parsing, and publish warnings for safer crawl control.

Review SAML metadata XML for import blockers, endpoint policy, entity roles, certificate dates, signature presence, and readiness evidence.

Calculate SLA availability from downtime, maintenance treatment, and elapsed window, then see remaining budget, burn rate, and breach risk.

Generate Prometheus SLO burn-rate alert rules with multi-window tiers, budget math, routing labels, YAML formats, and review tables.

Estimate SNMP polling load from devices, OIDs, intervals, retries, packet sizing, SNMPv3 overhead, MTU risk, and poller headroom.

Check whether a TLS leaf certificate belongs with a candidate issuer CA, with signature proof, DN checks, CA flag status, expiry risk, and policy scoring.

Match a TLS certificate against a CSR or RSA private key with SPKI pin comparison, chain warnings, encrypted-key handling, and exportable evidence.

Estimate TLS handshake CPU from request rate, connection reuse, full versus resumed costs, and surge peaks so edge capacity plans have room.

Trace a live TLS endpoint, inspect SNI, ALPN, cipher, certificate chain, and phase timings, and separate DNS, TCP, and TLS failures.

Turn TOML into config outputs with parse checks, path ledgers, type previews, and schema sketches so migrations are easier to audit.

Generate browser-local installer terminal replays for package-manager demos with seeded runs, warning jitter, progress traces, and ledgers.

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

Review Terraform variable blocks for risky defaults, secret-like fallbacks, type mismatches, nullable surprises, and prioritized fixes.

Estimate thread pool saturation from arrival rate, task time, queue depth, wait targets, and capacity scenarios with headroom warnings.

Calculate uptime budgets from SLA targets, downtime, maintenance policy, and elapsed period with burn pace and period-end status checks.

Estimate VM datastore capacity from thin or thick disks, snapshots, swap, growth, reserves, raw protection, and runway timing.

Estimate safe VM capacity after failover, maintenance, CPU and memory reserves, growth headroom, and large-VM placement checks.

Calculate vulnerability remediation due dates from CSV findings, apply severity SLAs and exploited caps, and surface overdue or due-soon queues.

Check domain registration records with RDAP-first lookup, WHOIS fallback, expiry timing, status clues, nameservers, contacts, and exports.

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

Convert YAML into JSON, normalized YAML, env, INI, and properties text with local parsing, document checks, path review, and schema output.

Plan ZFS usable capacity from vdev layout, disk size, RAID-Z padding, slop, reserves, and target-fit paths before buying drives.