DEV Community: Sadevz Labs

Regex Doesn't Have to Look Like Alien Mathematics

Sadevz Labs — Wed, 26 Aug 2026 12:55:56 +0000

Regular expressions are incredibly useful.

They're also remarkably good at making experienced developers stare at 30 characters for five minutes.

Take something simple:

^[A-Za-z0-9]+$
Once you know the pieces, it isn't nearly as intimidating.

'^' means the beginning of the string.

[A-Za-z0-9] matches letters and numbers.

means one or more.

$ marks the end of the string.

The problem with regex isn't necessarily writing it.

It's remembering all the tiny pieces.

The regex syntax I keep forgetting

Some of the most useful patterns are also the easiest to forget:

\d    digit
\w    word character
\s    whitespace
.     any character
+     one or more
*     zero or more
?     zero or one
^     start
$     end

Then there are groups, character classes, quantifiers, lookaheads and all the other things that send you searching the web again.

So I made myself a reference

While building Sadevz Tools, I created a Regex Cheat Sheet that keeps the common syntax and patterns together in one place.

You can bookmark it here:

sadevz.com

I also built a Regex Tester for actually experimenting with patterns:

Regex Tester — Test & Debug Regular Expressions Free | Sadevz

Live match highlighting, capturing groups, replace testing, examples and a cheat sheet. 100% client-side.

sadevz.com

The combination has become the workflow I prefer:

Reference → write pattern → test → adjust.

No account or installation needed.

Regex probably won't ever become beautiful.

But at least we can make it slightly less hostile. 😄

What Is Actually Inside a JWT?

Sadevz Labs — Sat, 22 Aug 2026 16:25:21 +0000

If you've worked with authentication, you've probably seen something resembling this:

xxxxx.yyyyy.zzzzz

That's a JSON Web Token, or JWT.

It looks cryptic at first, but its basic structure is surprisingly simple.

A JWT normally contains three sections:

1. Header

The header contains information about the token itself, such as the signing algorithm and token type.

2. Payload

The payload contains claims.

Depending on the application, these might include things such as a user ID, role, issuer or expiration time.

One important thing to remember: encoded does not mean encrypted.

You shouldn't assume information inside a JWT payload is secret simply because the token looks unreadable.

3. Signature

The signature is used to verify that the token hasn't been altered.

Put the three pieces together and you get the familiar:

header.payload.signature

A quick way to inspect one

While working on Sadevz Tools, I built a small browser-based JWT Decoder for inspecting token contents without needing to set up a project just to decode one.

You can use it here:

JWT Decoder — Decode & Inspect JSON Web Tokens Free | Sadevz

Paste any JWT to instantly view its header, payload, expiration and signature. 100% client-side, nothing leaves your browser.

sadevz.com

It's free and doesn't require an account.

I'm building these utilities around a simple idea: developer tools should sometimes just do one job and get out of your way.

What small developer utility do you find yourself repeatedly searching for?

JSON Formatting Is Simple. Debugging Bad JSON Isn't.

Sadevz Labs — Fri, 21 Aug 2026 17:50:24 +0000

JSON looks harmless until you're staring at a payload with a missing comma somewhere around line 200.

I've run into this plenty of times while working with APIs, configuration files and backend responses. Usually the problem is tiny:

a missing comma
an extra comma
mismatched brackets
single quotes instead of double quotes
an unescaped character
or simply a giant minified response that's impossible to read
The first thing I do: format it

Take something like:

{"user":{"name":"Sam","active":true},"roles":["admin","editor"]}

and turn it into:

{
  "user": {
    "name": "Sam",
    "active": true
  },
  "roles": [
    "admin",
    "editor"
  ]
}

Nothing magical happened, but the structure becomes immediately easier to inspect.

Formatting and validation aren't the same thing

This distinction is easy to overlook.

Formatting makes valid JSON readable.

Validation tells you whether the JSON is actually valid.

If the input contains broken syntax, prettifying it isn't enough. You first need to know where the parser stopped understanding the structure.

So I built the tiny tool I wanted

While building Sadevz Tools, I added a browser-based JSON Formatter & Validator for exactly this workflow.

You can try it here:

https://sadevz.com/json-formatter/

There's no signup or installation. Paste the JSON, work with it, and move on.

I'm gradually building more small browser utilities around the same idea: tools that solve one annoying problem without turning it into a SaaS product.

If you're a developer, I'd be interested to know what feature you consider essential in a JSON utility.

A Student's Blog

Sadevz Labs — Sat, 30 May 2026 19:22:21 +0000

One of my students just wrote his first article ever. I asked him to write on the relation between full stack developers and AI, and can AI replace full stack developers, if yes, why.
So, he did his research on the web and came up with the following article. Please have a look at it, and see a student's POV.

The article is at:

sadevz.com