About Curious Utilities

Our Story

The honest answer is work frustration.

We were deep into debugging an authentication issue — pasting JWT tokens into a decoder we'd found on the first page of Google results. Someone asked, half-joking: "does this site log everything we paste?" We didn't know. There was no way to know. The tool worked, but we had zero visibility into what happened to our tokens after hitting paste. That felt wrong.

That same evening we built a JWT decoder that runs entirely in the browser. No server involved. The JSON formatter came next, for the same reason — every existing option was either covered in ads, took 3 seconds to load, or required you to create an account just to format a string. We wanted one that opened and worked immediately.

TimeVault came from a different direction. We wanted to write something for future reference that genuinely couldn't be read early — not just "we promise we won't look." Every service we found either ran on infrastructure we'd have to blindly trust, or was a startup that might not exist in five years. Building something with client-side AES-256 encryption, where even we can't read the content before the unlock date, was the only approach we were comfortable with.

The cloud cost calculator was last — after spending too many hours trying to estimate infrastructure costs across AWS, Azure, and GCP pricing pages that all present numbers in different units with different assumptions baked in.

What we're actually trying to do

Build tools we'd use ourselves. That's the whole mission.

Concretely: no account creation required to access basic functionality. No tracking what you do inside the tools. No server that receives the data you paste. No ads that take over half the screen. No "upgrade to Pro" prompts after you've already started working.

We're not building a SaaS company around this. These are utilities that didn't exist the way we wanted them to, so we built them. If they're useful to you, that's good enough.

Our Values

Our Tools

We currently offer six developer utilities, each designed to solve a specific problem efficiently:

Technical Philosophy

We believe in building tools that are as simple as possible, but no simpler. Every tool we create follows these technical principles:

• Client-side processing — All data processing happens in your browser using native JavaScript APIs. Nothing is sent to our servers.
• No frameworks required — We use vanilla HTML, CSS, and JavaScript. This means faster load times, smaller bundle sizes, and fewer dependencies.
• Offline capable — After the initial page load, most tools work without an internet connection. Your workflow isn't interrupted by network issues.
• Mobile responsive — Every tool works on phones, tablets, and desktops. Development doesn't always happen at a desk.
• Accessibility focused — We strive to make our tools usable by everyone, including developers using screen readers or keyboard navigation.

What's actually being worked on

We add tools when we hit a specific problem we can't solve well with what's out there. No roadmap promises, but here's what's genuinely on the list right now:

• Better error messages in the JSON formatter for deeply nested structures — current ones are useful but not specific enough
• Side-by-side JSON diff view — comparing two configs is something we do constantly and haven't found a great browser tool for
• Recurring unlock dates in TimeVault — useful for annual check-ins, not just one-time messages

No timelines. These are side projects built in spare time. If you have something specific you need that doesn't exist, reach out — we've built tools based on single requests before.