March 27, 2026

Building tools.yetric.net: 85+ Developer Tools With No Friction

Why I built a collection of free developer tools, how the architecture works, and what I learned from keeping it simple.

  • Category Product
  • Type Essay
  • 5 min read

By Mattias Hising

The Itch

Every developer has been there: you need to quickly decode a JWT, format some JSON, or generate a hash — and instead of just doing it, you end up navigating past cookie consent banners, signing up for an account, or waiting for ads to load before the tool even renders.

It's a solved problem made annoying.

tools.yetric.net is my answer to that. Free, no accounts, no ads, no friction. Paste input, get output, copy and go.

What It Is

The site is a collection of over 85 web-based utilities organized into categories:

  • JSON — formatting, diffing, converting to TypeScript/Go/Zod schemas, generating SQL inserts, Prisma models, and more
  • Auth & Security — JWT decoder, JWT builder, hash generator, bcrypt, API key generator, HMAC signer
  • Security — CSP builder, CORS policy builder, password strength analyzer, security headers checker
  • Dev Utilities — curl → code, cron parser, regex tester, .env validator, Dockerfile generator, Nginx config builder, OpenAPI → TypeScript, HTTP status reference, and many more
  • CSS & Frontend — px/rem/em converter, CSS specificity calculator, Tailwind → CSS, z-index manager, gradient builder
  • SaaS & Metrics — MRR/ARR calculator, churn impact simulator, CAC/LTV, pricing tier designer
  • Docs — changelog generator, README builder, conventional commit linter, semver bump calculator

The philosophy is simple: every tool should be immediately usable with no setup, and every tool should do one thing clearly.

The Architecture

The stack is straightforward and intentionally boring.

Frontend: Next.js + TypeScript + Mantine

Next.js 16 with the App Router handles routing and server-side metadata generation. Mantine provides the component layer — it handles forms, code highlighting, and dark mode without requiring me to rebuild UI primitives from scratch. The entire frontend is TypeScript with strict mode enabled.

Each tool follows a consistent pattern:

  1. A page component that sets SEO metadata
  2. A tool component that wraps a shared <ToolPage> template with tool-specific config (title, description, input/output labels, syntax highlighting language)
  3. A typed API wrapper that posts to the backend and handles the { output, error } response

This means adding a new tool is low-overhead: write the backend logic, add a handler, add a typed API call, drop a <ToolPage> wrapper around it. The scaffolding is already there.

Backend: Go

The API is a Go service using the Chi router. Each tool gets its own handler and internal logic package. Go was the obvious choice here — it's fast, the standard library handles most of what's needed, and the tooling is straightforward.

The API enforces rate limiting (120 requests/minute per IP), a 1 MB body size cap, and returns a consistent { output: string, error?: string } shape from every endpoint. No surprises.

Deployment: Podman + Nginx

Both services run as containers behind an Nginx reverse proxy. We use Podman rather than Docker — it's fully open source, daemonless, and runs rootless by default, which aligns well with how we prefer to run things. GitHub Actions builds and pushes images to GHCR on every push to main, then pulls and restarts on the server via Podman Compose. Smoke tests run as part of the pipeline to catch obvious regressions.

flowchart TD
    subgraph CI["CI/CD (GitHub Actions)"]
        direction LR
        Push["git push"] --> Build["Build images"] --> GHCR["GHCR"]
    end

    subgraph Server["Production Server"]
        direction LR
        Nginx["Nginx\n(TLS + proxy)"] --> FE["Next.js\nFrontend"]
        FE -->|"POST /api/v1/..."| API["Go API"]
        API --> Tools["Tool Logic\n(Go packages)"]
    end

    Browser([Browser]) --> Nginx
    GHCR -->|"Podman Compose\npull & restart"| Server

A Few Decisions Worth Noting

URL-based input sharing. Any tool input can be encoded into the URL as a base64 query parameter. The page decodes it and auto-submits on load. This means you can share a link and the recipient lands directly on the result. It's a small feature that turns these tools from local scratch pads into something you can actually hand to a colleague.

CMD+K search. With 85+ tools, navigation needs to scale. There's a spotlight-style search overlay (CMD+K or /) that searches across all tool names and descriptions. It's faster than scrolling a sidebar.

Favorites and recents. Tools you've used recently appear at the top of the sidebar. Tools you've starred are always accessible. Both are stored in localStorage — no accounts needed.

Dark mode with Nord. The color scheme is Nord throughout — the Aurora palette for category accents, Frost for UI chrome. It's opinionated, but it holds together well and looks good at night when you're decoding a JWT at 11pm.

What I Learned

The boring architecture wins. Next.js + Go + Docker is not a novel combination. That's the point. Every piece of it has known tradeoffs, good documentation, and no surprises. When you're building a tool that needs to just work, boring infrastructure is a feature.

Consistency beats cleverness. The <ToolPage> pattern means every tool works the same way. Users don't need to re-learn the interface for each tool. It also means I can add new tools quickly without thinking too hard about UI structure.

The search overlay is more important than the navigation. Once you have 30+ tools, the sidebar becomes hard to scan. The spotlight search is what most people use after the first visit. Building it earlier would have been worth it.

What's Next

The tool count keeps growing. There are several more DevOps and database utilities in progress. I'm also looking at adding a way to chain tools together — pipe the output of one into the input of another — which would unlock some useful workflows.

There's also something that keeps coming up: a CLI. The backend is already a clean API — every tool is a single POST with a plain text response. Wrapping that in a terminal client would let you pipe directly from your shell: cat schema.json | yetric json:to-typescript. No browser required. That one is on the list.

If you use it and find something missing or broken, the site links to GitHub for issues.

tools.yetric.net — no signup required.