Building a Local-First Toolbox for Everyday Digital Work

devkitlab — Wed, 10 Jun 2026 09:03:05 +0000

I’ve been working on a small tools website called DevKitLab.

It’s not a complicated idea. Most of the tools are things people already know: JSON formatting, JSON diff, regex testing, cron expressions, QR code generation, even Morse code.

None of these sound new.

But that’s kind of the point.

A lot of online tools are “good enough” only when the input is perfect. They work for clean examples, small snippets, and simple cases. But in real work, the data is usually not that clean.

It may come from logs.
It may come from an API response.
It may be copied from someone else’s system.
It may be too large for a basic textarea.
It may be valid, but still hard to read.

So I didn’t want DevKitLab to be just another long list of small utilities.

I wanted to take some common tools and make them feel a little more considered.

JSON Formatter: not just pretty-printing

JSON Formatter is one of the tools I cared about the most.

I use JSON formatters all the time, but most of them feel the same: paste JSON, click format, get indented output.

That works when the input is already valid and small.

But that’s not always what happens.

Sometimes the JSON is copied from logs and has extra characters around it.

Sometimes it has a trailing comma or a missing quote.

Sometimes a value is actually an escaped JSON string, so the structure is hidden inside another string.

Sometimes the file is a few MB, and the page starts to feel slow.

For this tool, I didn’t want to build only a textarea with a format button.

I wanted it to feel more like a lightweight JSON editor.

It can try to repair common JSON issues.
It can expand escaped JSON values so you don’t have to copy them into another tool.
It supports folding and expanding nodes, so large JSON is easier to browse.
It is designed to stay usable with JSON that is a few MB in size.

The experience is closer to working in VS Code than using a basic online formatter.

This tool shaped a lot of how I think about the rest of the site.

A small tool should not only work for demo input. It should help with the messy cases people actually run into.

JSON Diff: comparing structure, not just text

JSON Diff is another tool I wanted to make more useful than a plain text comparison.

When I compare JSON, I’m usually not interested in whitespace or formatting changes. I want to know what actually changed in the data.

Did a field get added?
Was something removed?
Did a value change?

Is the difference real, or is it just formatting?

This happens a lot when comparing API responses, config files, test results, or data from two environments.

A normal text diff can be noisy for JSON. If the formatting changes, it may look like everything changed, even when the data is mostly the same.

So the goal of JSON Diff is to make the meaningful changes easier to see.

For me, this kind of tool is useful when it reduces the amount of guessing. I don’t want to stare at two large blocks of text and mentally filter out the noise.

Regex Tester: make debugging feel less like guessing

Regex is powerful, but it’s also very easy to get wrong.

Most regex testers can show whether a pattern matches the text. That is useful, but it is not always enough.

When I debug a regex, I usually want to understand the pattern piece by piece. If I hover over a part of the expression, I want to see what it means. If something matches, I want to know why. If something does not match, I want to find the exact part that needs to change.

So I wanted this tool to feel more like a small regex workspace, not just a match checker.

The flow I had in mind was:

Write a pattern.
Hover over parts of the regex to understand what they do.
Test it against real text.
See highlighted matches and match details.
Try replace when the goal is transformation, not just matching.
Try split when the pattern is used as a separator.
Use explain to make the expression easier to read.
Export the pattern as code when it is ready to use.

DevKitLab Regex Tester showing a regular expression tested against sample text with highlighted matches

The point is not to make regex simple. Regex probably won’t ever feel simple.

But the tool should make the feedback clearer. It should help you move from “I think this pattern works” to “I understand why this pattern works, and I can use it in code.”

Cron Expression: turning a short string into real times

Cron expressions are small, but they are not very readable.

Something like 0 9 * * 1-5 is fine if you write cron all the time. But once the expression becomes a little more complex, I often want to double-check it.

Will it run when I think it will run?
What are the next few execution times?
Did I misunderstand the day-of-week field?
Is there any timezone-related confusion?

That’s what I want from a cron tool.

Not just validation, but a quick way to turn the expression into something human-readable.

This is one of those tools that feels small, but can save you from a very annoying mistake.

QR Code Generator: simple, but still worth polishing

A QR code generator sounds almost too simple.

You enter some text, and it generates a QR code.

But even simple tools can be made smoother.

Sometimes the input is a URL.
Sometimes it is plain text.
Sometimes you want to adjust the size.
Sometimes you want a quick download.
Sometimes you just want the page to stay out of your way.

For this kind of tool, I don’t think the goal is to add a huge number of features. The goal is to make the common flow fast and predictable.

Open it.
Generate the QR code.
Download or copy it.
Move on.

Morse Code: not every tool has to be serious

Morse Code is a little different from the others.

It is not something most people use every day. It is not like JSON, regex, or cron.

But I still wanted to include it because a toolbox does not have to be only about serious work.

Some tools are for debugging.
Some are for productivity.
Some are just fun to have.

Morse code sits somewhere in that last category.

It may not be the most practical tool on the site, but I like having a few tools that make the project feel less rigid.

What I’m trying to build

The more I work on DevKitLab, the less I care about simply adding more tools.

More tools are useful, of course. But quantity alone is not very interesting.

What matters more to me is whether each tool feels like someone actually thought about how it would be used.

JSON Formatter should be more than pretty-printing.

JSON Diff should make real data changes easier to see.

Regex Tester should make debugging clearer.

Cron Expression should turn abstract syntax into actual times.

QR Code Generator should keep the common flow quick.

Morse Code can just be simple and enjoyable.

None of these tools are huge products by themselves.

But if each one removes a little friction, the whole toolbox becomes more useful.

Why local-first matters to me

Another thing I care about is keeping things local whenever possible.

If you only need to format JSON, that should not require uploading it.

If you are testing regex, the text can stay in the browser.

If you are generating a QR code, the browser can do that.

If a tool can run locally, I’d rather keep it local.

Not every tool can work that way, and that’s fine.

But for many everyday utilities, the browser is already enough.

And in practice, the data people paste into tools is not always meaningless. It can come from work, APIs, configs, logs, files, or private notes. Even when it is not extremely sensitive, people should not have to send it somewhere if there is no reason to.

So local-first is not just a technical preference for me. It is part of the product experience.

What’s next

DevKitLab is still early.

Some tools are close to the direction I want. Some are still too basic and need more work.

I want to improve the examples, make the local-processing behavior clearer, polish the interactions, and connect related tools in a more natural way.

I don’t want it to become a random collection of utilities.

I want it to become the kind of site you open when you have a small digital task and just want to get it done without friction.

A JSON response to inspect.
Two JSON objects to compare.
A regex to debug.
A cron expression to verify.
A QR code to generate.
A Morse message to play with.

Small things, but they come up all the time.

Project: DevKitLab

If you use small online tools often, I’d love to know:

What’s a tool you use regularly, but still feel could be much better?

DEV Community: devkitlab