DevOps Tools

Generate .htaccess rules for redirects, HTTPS enforcement, canonical hosts, caching and compression, with each directive explained.

Generate an Ansible playbook and role skeleton with idempotent module usage, handlers, check mode support and the patterns that keep a playbook safe to run repeatedly.

Format and beautify JSON API responses.

Build an IAM policy from services, actions and resource ARNs with condition keys for MFA, source IP and encryption, and warnings for the wildcards that make a policy permissive by accident.

Assess whether backups would actually restore, against the failure modes that make them useless when needed.

Convert images to Base64 data URLs.

Plan a canary rollout with traffic percentages, bake time per step and the sample size each step needs to detect a regression, plus automatic rollback thresholds.

Toggle read, write and execute for owner, group and others to get the octal chmod number, the symbolic string and the ready command. Understand what each permission actually allows.

Analyze CI/CD pipelines for security risks and misconfigurations.

Checklist based analyzer for CI/CD pipeline security gaps.

Validate YAML syntax for GitHub Actions, GitLab CI, and other CI/CD pipelines.

Forecast cloud infrastructure costs based on usage patterns.

Estimate savings from rightsizing, reserved capacity, spot instances and storage tiering, and where cloud bills actually leak.

Analyze a Dockerfile and suggest changes to improve caching and reduce image size.

Build and validate cron expressions with an intuitive visual interface.

Generate and verify cron schedule expressions with a visual editor.

Calculate the connection pool size your application actually needs from concurrency and query time, and see why a larger pool usually makes throughput worse rather than better.

Plan deployment rollback strategies and procedures.

Validate Docker Compose YAML files for syntax errors, missing fields, and common misconfigurations.

A new tool extracted from the codebase.

Analyze Dockerfiles for security issues and best practices violations.

Analyze Dockerfiles for security vulnerabilities and best practices.

Generate a .editorconfig file to enforce consistent coding styles across editors and IDEs — indent style, size, charset, line endings and trailing whitespace. Private.

Calculate how many primary shards an index needs from data volume and growth, check the shard count against node heap, and size a rollover policy that avoids oversharding.

Compare two .env files and find differences.

Estimate GitHub Actions cost from minutes used and a per-1000 minutes rate.

Size Gunicorn workers and threads from CPU count and workload type, choose between sync, gthread and async worker classes, and set the timeouts that stop a slow request taking the process down.

Compare hash values for file integrity verification.

Paste your infrastructure-as-code and the observed cloud state to see what was added, removed or changed, with security-relevant attributes highlighted. A real key/value diff, in your browser.

Convert a JSON configuration object into .env format, with flattening, quoting and naming conventions handled correctly.

Convert JSON to YAML in your browser. Every valid JSON document is valid YAML, so this direction is lossless.

Size a JVM heap against a container memory limit, accounting for metaspace, thread stacks, code cache and direct buffers, and avoid the off-heap overhead that causes container OOM kills.

Decode and verify JSON Web Tokens.

Calculate the partition count a topic needs from producer and consumer throughput, check it against broker limits, and size the disk that retention actually requires.

Lint Kubernetes configurations for security best practices.

Generate liveness, readiness and startup probe configuration with timings derived from your application start and response times, and avoid the restart loops a wrong probe causes.

Calculate total CPU/memory requests and limits across replicas from per-pod resource values.

Validate and analyze Kubernetes manifests for common issues.

Convert between virtual users, requests per second and response time using Little’s Law, size a load test correctly, and see why adding users past saturation measures queueing rather than capacity.

Parse and analyze application logs.

Estimate log storage volume and cost from event rate and retention period, and set retention you can defend.

Generate a logrotate configuration with the right rotation frequency, retention, compression and post-rotate signal handling, and avoid the copytruncate data loss trap.

Generate shields.io-style Markdown and HTML badges for your README — label, message, color and style. Live preview and copy-ready code. Free, private, instant.

Generate a my.cnf tuned for your hardware, covering the InnoDB buffer pool, log file sizing, flush method, connection handling and the settings whose defaults still assume a much smaller machine.

Generate Nginx server block configurations for reverse proxy, static sites, SSL, and redirects.

Size Nginx worker processes and connections from cores and traffic, calculate the file descriptor limit a proxy actually needs, and generate the tuned configuration.

Size a PHP-FPM pool from available memory and request characteristics, choose between static, dynamic and ondemand process managers, and generate the pool configuration.

Generate a PodDisruptionBudget from replica count and availability requirements, and avoid the two configurations that deadlock a cluster node drain permanently.

Generate a postgresql.conf tuned for your hardware and workload, covering shared buffers, work memory, WAL sizing, autovacuum and the planner settings that assume spinning disks by default.

Generate a .pre-commit-config.yaml with formatters, linters, secret scanning and file hygiene hooks for your languages, pinned to revisions and wired for CI.

Build Prometheus alerting rules for availability, latency, saturation and SLO burn rate, with the for clause, labels and annotations that make an alert actionable rather than noisy.

Build PromQL queries for rates, error ratios, histogram percentiles, top-k and aggregation, with the counter and gauge rules that make the difference between a correct query and a plausible one.

Estimate Redis memory from key count, value size and data structure, including the per key overhead people forget, and choose an eviction policy and maxmemory that avoid an OOM.

Generate a renovate.json with grouping, scheduling, automerge rules and stability days tuned to how much update noise your team can absorb.

Build an rsync command with the right archive, delete, exclude and bandwidth options, and understand the trailing slash rule that decides where files actually land.

Generate an S3 lifecycle configuration with storage class transitions, expiry, noncurrent version cleanup and abandoned multipart upload removal, with the cost of each transition shown.

Scan code for accidentally committed secrets and credentials.

Format and indent SQL queries for readability. Handles joins, subqueries and CTEs, supports common dialects, and runs entirely in your browser.

Calculate error budgets based on SLO targets and actual uptime.

Generate a systemd unit file with the right service type, restart policy, dependency ordering, resource limits and sandboxing directives, with each choice explained.

Generate a matching systemd timer and service pair with OnCalendar expressions, randomised delay, persistence across reboots and the correct dependency wiring.

A new tool extracted from the codebase.

Convert an SLA percentage into actual permitted downtime per day, month and year, and see what each extra nine costs.

Validate YAML syntax, find errors with line numbers, and format/beautify YAML files instantly.