Sysadmin

Generate reviewed .env and .env.example files with key cleanup and secret-aware placeholders while flagging quote or duplicate risks locally.

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.

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.

Inspect a local ZIP, TAR or GZIP archive and download selected safe files as a normalized ZIP package with blocked paths clearly excluded.

Turn IPv4 and IPv6 CIDR rows into platform-specific prefix-list syntax, with normalized networks and ordered-policy warnings.

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.

Plan backup rotation capacity across daily through yearly retention tiers with binary units plus compression, growth and dedupe assumptions.

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.

Generate Cisco ACL commands from IPv4 flow rows for IOS, NX-OS, and ASA with platform-aware address conversion and safety checks before use.

Generate Cisco interface commands for routed, access, or trunk ports with profile-aware syntax plus normalized VLAN lists and review warnings.

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 theoretical FLOP/s or OP/s from architecture inputs, then compare compute utilization with the memory-bandwidth roof.

Compare approved and observed configuration snapshots, classify meaningful drift, and prioritize changed or missing security settings.

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

Build a user or system crontab entry from a preset, pasted line, or five-field schedule with syntax checks and host-review warnings.

Size an IPv4 DHCP scope from real pool ranges and peak demand, then test policy choices against growth and target headroom before deployment.

Look up DNS records for a domain, URL or IP through Google or Cloudflare with response codes, returned TTL evidence and DNSSEC flags.

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

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

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

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

Check HA peer snapshots for ownership drift, standby readiness, stale synchronization and heartbeat failures with service and priority evidence.

Audit hostname inventories against RFC and Kubernetes syntax, organization regex rules and duplicate policy with browser-local evidence.

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

Allocate IPv4 subnets in an ordered parent CIDR, with exact usable ranges and checks for VLSM fit, alignment gaps and remaining space.

Build dependency-ordered IPv4 renumbering waves with CIDR and DNS/DHCP timing checks, window-fit rules and rollback-ready runbooks.

Size and place IPv4 child subnets from host demand, with growth headroom and reservation rules that expose gaps, overflow and usable ranges.

Normalize one IPv6 literal into canonical compressed and expanded forms with preserved prefix and zone context plus binary and reverse-DNS views.

Calculate an IPv6 network from an address and prefix, then review canonical boundaries, child-prefix capacity and reverse DNS or EUI-64 guidance.

Turn incident action rows into due-state and owner follow-up views with blocker, missing-detail, stale-overdue and workload checks.

Calculate an IPv4 subnet boundary from CIDR or a dotted mask, then check usable hosts, special-purpose ranges and reserve-adjusted capacity.

Split an IPv4 parent block into equal CIDR children and check usable hosts, gateway placement and capacity fit across the complete subnet plan.

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.

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.

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

Generate NTP configuration for Linux daemons or Cisco devices with source compatibility checks and warnings for unsafe fallback settings.

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

Build a network change plan with readiness gates and ordered cutover steps, then review rollback evidence and residual-risk guidance.

Estimate useful network throughput and transfer time from link capacity and RTT with TCP window, loss and packet-rate bottleneck checks.

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

Generate an OpenVPN client profile with matched routing, TLS, cipher, and credential choices plus import and security review warnings.

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

Plan a PoE switch from endpoint demand and cable loss, then check reserve capacity against powered ports, startup surge and shedding priority.

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.

Build or import a Bash PS1 prompt with ordered tokens and safe ANSI styling plus a terminal preview and setup text for real-shell testing.

Review pasted or current-request proxy headers, trace the trusted edge from the right, and flag spoofable client-IP evidence and disclosure clues.

Build FreeRADIUS client stanzas from NAS rows with device-specific secret checks, address-scope warnings, and hardened security settings.

Estimate RADIUS request load from access, accounting, retries, and bursts, then check per-server budgets and N-1 failover headroom.

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.

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.

Calculate planned RAID capacity from drive sizes and layout, including spares, mixed-drive loss, operating reserves, and rebuild exposure.

Estimate replication backlog catch-up time from sustained write rate, outage volume, usable throughput, apply limits and recovery targets.

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

Calculate SSD endurance from DWPD or TBW, size the rating for per-drive host writes, and forecast SMART-based wear and replacement timing.

Build OpenSSH Host blocks from CSV inventory rows with inherited defaults and warnings for risky keys, jump hosts or connection sharing.

Edit an SSH client config locally, test Host wildcards, preserve Match and Include text, and flag risky or duplicate directives before use.

Convert SSH public keys among OpenSSH, SSH2 and PEM locally while verifying key identity through matching SHA-256 fingerprints and safety checks.

Extract a supported SSH public key locally, verify its SHA-256 fingerprint, and assemble a reviewed authorized_keys entry from key material.

Estimate snapshot reserve from changed-block churn and retention, then test reduction and headroom against growth, burst load and current capacity.

Generate reviewed static-route commands across host and network CLIs with CIDR normalization plus priority checks and rollback-ready delete output.

Plan IPv4 child subnets from a parent CIDR, compare post-reserve host capacity, and pack ordered VLSM demands into valid boundaries.

Build access or trunk switchport CLI for IOS, NX-OS, and Arista EOS with normalized VLAN lists plus platform-aware syntax and paste-safety checks.

Classify pasted syslog and application logs by RFC severity, measure the error-plus share, and spot emitters that cross your review threshold.

Estimate searchable syslog storage from EPS and event size with retention, compression and index overhead plus stored copies and disk reserve.

Convert TB/TiB/GB/GiB through exact byte totals and compare decimal vendor labels with binary system readouts without mistaking the gap for loss.

Estimate UPS runtime from real load and battery energy while applying efficiency and health factors, reserve, watt and VA limits and shutdown margin.

Plan VLAN ID capacity across reserved and existing ranges, then test allocation runway and IPv4 host fit for each new segment.

Compare switch VLAN evidence with intended trunk and native rules plus database, reserved-VLAN, and VLAN 1 policy before a change.

Turn pasted port moves into timed VLAN migration waves with risk and native-VLAN checks, validation gates and an explicit rollback plan.

Plan a VM migration window from memory and disk payloads, using dirty-page churn and usable bandwidth to estimate total time and downtime.

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.

Split an IPv4 parent block into visual CIDR leaves, rejoin aligned siblings and verify each range, usable count and complete address coverage.

Estimate WAN round-trip latency from route distance and path overhead to compare target headroom, dominant delays and serial application wait.

Extract WWN and NAA values from SAN text and normalize the hex before decoding identifier fields or flagging fragments for operational review.

Detect visible server and application clues at a public URL, including CDN or proxy evidence across redirects and a clear confidence score.

Generate WireGuard server and client configurations with CIDR validation, route-scope warnings, and explicit placeholders for safer key handling.

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

Translate Unix permission bits into octal and symbolic chmod commands, then review baselines plus special-bit, recursion and symlink risks.

Generate a dnsmasq IPv4 DHCP scope with CIDR and pool checks plus reservations, client options and optional PXE lines for a review-ready config.

Build bounded iptables or ip6tables commands for a packet path with explicit CIDR and port matches, persistence choices, and production-safety checks.

Draft a systemd service unit from workload, account, restart and hardening choices with local review findings and host verification commands.