Dev Rajput

Posted on Aug 20

I Built DEVRIAN: Privacy-First Developer Tools That Run in Your Browser

#devtools #webdev #javascript #security

How many times have you opened a random website just to format JSON, decode a JWT, generate a UUID, test a regex, or calculate a hash?

I’ve done it more times than I’d like to admit.

The annoying part isn't the task itself.

It’s the workflow:

Find a tool
Open another website
Paste potentially sensitive data
Deal with ads or unnecessary UI
Perform one tiny task
Close the tab
Repeat the same thing tomorrow

That’s why I started building DEVRIAN.

👉 https://devrian.in/

What is DEVRIAN?

DEVRIAN is a browser-based developer workspace focused on small, practical utilities that developers use constantly.

The idea is simple:

If a developer utility can run locally in the browser, why send the input to a server at all?

DEVRIAN is designed around local browser execution wherever possible, so tools can process your data directly in your browser instead of requiring unnecessary server-side processing.

That makes the workflow faster, simpler, and much more comfortable when you're working with things you don't want leaving your machine.

What can you do with it?

The current toolkit includes:

JSON

Format, validate, repair, and minify JSON payloads.

Useful when you're debugging:

API responses
configuration files
request payloads
nested objects
malformed JSON

JWT

Inspect JSON Web Tokens directly in the browser.

You can work with:

JWT headers
payload claims
expiration information
token structure

Useful when debugging authentication and API integrations.

Base64

Encode and decode Base64 data without opening a separate utility.

It also supports common encoding workflows such as URL-safe Base64, Hex data, Data URIs, and UTF-8 text.

UUID

Generate UUIDs when you need identifiers during development.

DEVRIAN supports UUID v4 and UUID v7 generation, including bulk generation.

Regex

Test and debug regular expressions with real-time matching and capture-group information.

No need to create a temporary script just to check whether a pattern behaves the way you expect.

URL

Encode and decode URLs and query parameters.

The URL tool also provides an interactive way to inspect query parameters, which is particularly useful when debugging API requests.

Hashes

Generate hashes such as:

SHA-256
SHA-512
SHA-1
MD5

Useful for development, debugging, checksums, and working with cryptographic message digests.

HTML

Encode and decode HTML entities and special characters.

This is especially handy when you're dealing with escaped HTML, user input, or debugging encoded content.

Timestamps

Convert between Unix timestamps and human-readable date formats such as ISO 8601, UTC, and local time.

Because nobody enjoys manually figuring out what 1755... means.

Passwords

Generate high-entropy passwords and API secrets using browser-side cryptographic randomness.

Why browser-local processing matters

Developer tools often deal with data that isn't meant to be public.

Think about:

JWTs
API payloads
internal URLs
configuration values
identifiers
logs
encoded data
test credentials
customer-related development data

For these kinds of tasks, uploading the input to a random online utility isn't always a great workflow.

DEVRIAN's approach is to keep these utilities browser-native whenever the operation allows it.

The goal isn't to make developers think about privacy every time they format JSON.

The goal is to make the privacy-friendly workflow the easy workflow.

It's not just a collection of random utilities

Another thing I'm working toward with DEVRIAN is connecting individual tools into actual developer workflows.

For example:

Debugging an API token

JWT Debugger → inspect claims → check expiration → understand the token structure

Preparing an API payload

JSON Formatter → validate → inspect → format the final payload

Handling user input

Regex Tester → validate patterns → inspect matches → test edge cases

Working with timestamps

Timestamp Converter → inspect Unix timestamps → compare with ISO dates → understand what your backend is actually returning

Instead of having ten unrelated websites bookmarked, the idea is to build one developer-focused workspace where these small tasks live together.

No installation. No account required just to format some JSON.

That's another part of the idea.

You shouldn't need to:

Download an application
Create an account
Configure a workspace
Install an extension

just because you need to inspect a JSON response for 30 seconds.

Open the browser.

Use the tool.

Get the result.

Move on.

What I'm building next

DEVRIAN is still being actively developed.

The bigger vision is to turn these individual utilities into a more complete privacy-first developer workspace.

That means better workflows, more developer utilities, better ways to move between related tasks, and eventually a workspace experience that feels more like an engineering environment than a collection of online calculators.

I'm also interested in making the tools genuinely useful for real development work rather than adding features just for the sake of having a bigger tool count.

I want developer feedback

If you work with APIs, authentication, frontend development, backend development, security, or just spend too much time opening tiny utility websites, I'd genuinely like to know:

What developer utility do you use every week that you wish was faster, cleaner, or more private?

And if you try DEVRIAN: