Most “free online tools” sites fall into two camps: a giant client-side bundle that ships everything on first load, or a thin shell that depends on a backend for every interaction. Neither is necessary.
sitetoolsbox.com is a navigation directory plus a set of browser-based and server-assisted tools. It runs on PHP, ships a JSON formatter with zero upload, a bulk domain checker backed by RDAP, and a catalog of categories that search engines can actually index. The architecture is deliberately boring: static where it can be, dynamic where it must be, and lazy everywhere else.
The client-side tool: JSON Formatter with zero upload
The JSON formatter is the cleanest example of a tool that should never touch a server. Users paste JSON, format it, validate it, and copy it back. If that data leaves the browser, you have added latency, bandwidth cost, and a privacy liability for no reason.
The implementation is a single lazy-loaded module. It uses JSON.parse / JSON.stringify for formatting and validation, and it runs entirely on the main thread only because the input size is bounded. For anything larger, a Worker would be the next step—but for typical payloads under a few hundred kilobytes, the overhead of a Worker is not worth it.
The key architectural choice is when the module loads: not on page load, but when the user opens the tool. The directory page does not import the formatter, the hash generator, or any other tool module. Each tool route lazy-loads exactly one chunk:
js
const tool = tools[slug];
const ToolComponent = lazy(tool.load);
This keeps the initial JavaScript on directory and category pages under control. If you ship every tool on first paint, INP suffers on mid-range mobile devices before the user even taps anything.
The server-side tool: bulk domain checking with RDAP and curl_multi
Domain availability checking is the opposite case. You cannot check a .com registration from the browser; the lookup must happen on a server that speaks RDAP or WHOIS.
The naive approach—sequential WHOIS queries—falls apart for bulk checks. WHOIS is plain text over port 43, with no standard response format, no concurrency support, and aggressive rate limiting. Parsing "No match for" versus "Not found" across registries is a regex nightmare.
RDAP fixes most of this. It is JSON-based, uses HTTP status codes (200 for registered, 404 for available), and most major registries support it. The tool maps each TLD to its RDAP endpoint and falls back to WHOIS only when RDAP is unavailable.
For bulk requests, the critical piece is curl_multi—PHP’s parallel HTTP client. A sequential loop of 200 domains might take minutes and trigger rate limits. curl_multi fires up to 30 concurrent RDAP queries, which is fast enough to be useful while still respecting registry limits.
php
function domainCheckBatch($domains, $concurrency = 30) {
$rdapDomains = [];
foreach ($domains as $d) {
$tld = substr(strrchr($d, '.'), 1);
if (domainRdapEndpoint($tld)) $rdapDomains[] = $d;
}
// curl_multi with $concurrency handles
}
This is the pattern that makes the bulk checker practical: use the right protocol (RDAP) and the right concurrency model (curl_multi) , instead of brute-forcing WHOIS.
The directory: static HTML, structured data, and no empty pages
The navigation directory is a separate concern. It is a discovery surface, and discovery surfaces live or die by indexability.
Every tool and category page has a real
Top comments (0)