DEV Community: Sahil Bedi

7 JSON Formatting Mistakes Every Developer Has Made

Sahil Bedi — Tue, 28 Jul 2026 10:50:43 +0000

We've all been there.

You copy an API response into your editor, make a small change, send the request again...

…and suddenly you're staring at:

Unexpected token } in JSON at position 128

Or:

Invalid JSON

After several minutes of debugging, you realize it was a missing comma or an extra quote.

JSON is one of the most common data formats in modern software development, but even experienced developers make formatting mistakes. The good news is that most of these issues are easy to spot once you know what to look for.

Here are seven of the most common JSON formatting mistakes I've encountered over the years.

1. Trailing Commas

One of the most frequent mistakes.

❌ Invalid

{
  "name": "John",
  "age": 30,
}

✅ Correct

{
  "name": "John",
  "age": 30
}

Unlike JavaScript objects, JSON does not allow trailing commas.

2. Missing Double Quotes Around Property Names

JSON requires every property name to be enclosed in double quotes.

❌ Invalid

{
  name: "John"
}

✅ Correct

{
  "name": "John"
}

Many developers accidentally write JavaScript object syntax instead of valid JSON.

3. Using Single Quotes Instead of Double Quotes

Another common mistake is using single quotes for string values.

❌ Invalid

{
  "city": 'London'
}

✅ Correct

{
  "city": "London"
}

JSON only supports double quotes.

4. Forgetting to Escape Special Characters

Strings containing quotation marks must escape them properly.

❌ Invalid

{
  "message": "He said "Hello""
}

✅ Correct

{
  "message": "He said \"Hello\""
}

The same applies to backslashes and certain control characters.

5. Incorrect Data Types

Everything might look correct while still producing incorrect data.

For example:

{
  "isActive": "true"
}

This stores a string, not a boolean.

Correct version:

{
  "isActive": true
}

Likewise:

{
  "count": "25"
}

is different from

{
  "count": 25
}

Choosing the correct data type prevents many downstream bugs.

6. Mismatched Braces or Brackets

Large JSON files become difficult to read.

A missing brace can invalidate the entire document.

For example:

{
  "users": [
    {
      "id": 1,
      "name": "Alice"
    ,

Formatting your JSON immediately makes these issues much easier to identify.

7. Trying to Read Minified JSON

Many APIs return compressed JSON like this:

{"id":1,"name":"John","roles":["Admin","Editor"],"settings":{"theme":"dark","language":"en"}}

Technically it's valid.

Practically, it's painful to debug.

Formatting it into an indented structure makes nested objects and arrays much easier to understand.

My Workflow

Whenever I'm debugging an API response, I usually follow the same process:

Validate the JSON first.
Format it for readability.
Check nested objects.
Verify data types.
Look for missing commas or braces.

It only takes a few seconds and saves a surprising amount of debugging time.

A Small Tool That Helps

While building ToolNudge, I found myself repeatedly pasting JSON into editors just to check whether it was valid or to make it readable.

To simplify that workflow, I built a browser-based JSON Formatter & Validator.

It lets you:

Format JSON instantly
Validate syntax
Detect formatting errors
Minify JSON when needed

Everything runs directly in the browser, so your data never leaves your machine.

👉 https://toolnudge.com/json-formatter-validator

Final Thoughts

JSON isn't complicated, but small formatting mistakes can interrupt your flow and waste valuable debugging time.

A quick validation step before sending requests or committing configuration files can prevent many of the errors developers encounter every day.

What JSON mistake has wasted the most time for you?

I'd love to hear your experiences in the comments.

5 Browser-Based Tools I Use Almost Every Day as a Developer

Sahil Bedi — Tue, 23 Jun 2026 10:23:18 +0000

As developers, we spend a lot of time solving complex problems.

But surprisingly, many small frustrations come from repetitive tasks:

Reading unformatted JSON
Debugging JWT tokens
Testing regular expressions
Reviewing long SQL queries
Sharing links and credentials

Over time, I've found that browser-based utilities are often faster than installing dedicated software for these tasks.

Here are five tools I frequently use.

1. JSON Formatter & Validator

Working with APIs often means dealing with large JSON responses.

Trying to understand a single-line JSON payload is painful.

A formatter makes it much easier to:

Beautify JSON
Validate syntax
Navigate nested structures
Spot missing fields

Tool:

https://toolnudge.com/json-formatter-validator

2. JWT Decoder & Validator

Authentication issues are difficult enough without having to manually inspect JWT tokens.

A decoder helps quickly:

Inspect claims
Verify expiration times
Understand token payloads
Debug authentication problems

Tool:

https://toolnudge.com/jwt-decoder-validator

3. Regex Tester & Validator

Regular expressions are powerful, but getting them right usually takes several iterations.

Instead of repeatedly changing code and running the application, a regex tester provides immediate feedback.

Useful for:

Email validation
Pattern matching
Text extraction
Log analysis

Tool:

https://toolnudge.com/regex-tester-validator

4. SQL Formatter & Beautifier

Readable SQL saves time.

Complex queries become much easier to review when they're properly formatted.

Benefits include:

Improved readability
Easier debugging
Better collaboration
Reduced mistakes

Tool:

https://toolnudge.com/sql-formatter-beautifier

5. QR Code Generator

This may not sound like a developer tool, but I find it surprisingly useful.

Common use cases include:

Sharing URLs
WiFi credentials
Contact information
Event registrations

Tool:

https://toolnudge.com/developer-tools/qr-code-generator

Other Utilities I Frequently Use

Besides these, I regularly use:

Markdown Editor & Preview
Base64 Encoder & Decoder
Unix Timestamp Converter
Cron Expression Generator
API Key Generator
Hash Generator
XML Formatter & Validator
YAML Formatter & Validator

Why I Prefer Browser-Based Tools

Most utility tasks don't require installations, accounts, or server-side processing.

I prefer tools that are:

Fast
Privacy-focused
Accessible from anywhere
Available when I need them

Small tools don't solve complex engineering problems.

But they remove friction from everyday workflows.

And sometimes that's enough to save a surprising amount of time.

What browser-based utility do you find yourself using most often?

Why I Built ToolNudge: A Privacy-First Collection of Browser-Based Utilities

Sahil Bedi — Sun, 14 Jun 2026 07:22:05 +0000

Over the years, I've found myself repeatedly searching for small utility tools.

JSON formatters.

JWT decoders.

Regex testers.

QR code generators.

Text cleaners.

Most of these tools solve simple problems, but they often come with a few frustrations:

Excessive advertisements
Slow loading times
Account requirements
Unclear privacy practices
Unnecessary server-side processing

For many utility tools, there is no reason user data should leave the browser at all.

That observation eventually led me to start building ToolNudge.

The Idea

ToolNudge is a collection of browser-based utilities designed around a few simple principles:

Fast
Privacy-first
Free to use
No unnecessary data collection
Mobile-friendly
SEO-friendly

Whenever possible, tools run entirely in the browser.

This means users can format JSON, decode JWTs, clean text, generate QR codes, and perform many other tasks without sending their data to external servers.

What I've Built So Far

Some of the current utilities include:

JSON Formatter & Validator
JWT Decoder & Validator
Regex Tester
SQL Formatter
Text Cleaner
QR Code Generator
Meta Tag Generator
Sitemap Generator

And many more.

Lessons Learned

One of the biggest lessons has been that small tools solve real problems.

Developers, creators, marketers, and business users often spend more time on repetitive tasks than on complex work.

Removing friction from those workflows can have a surprisingly large impact.

What's Next

I'm continuing to expand ToolNudge with additional developer tools, text utilities, SEO tools, and creator-focused utilities.

The goal is simple:

Create useful tools that are fast, accessible, and respectful of user privacy.

I'd love to hear:

What utility tools do you find yourself using most often?

DEV Community: Sahil Bedi

7 JSON Formatting Mistakes Every Developer Has Made

1. Trailing Commas

2. Missing Double Quotes Around Property Names

3. Using Single Quotes Instead of Double Quotes

4. Forgetting to Escape Special Characters

5. Incorrect Data Types

6. Mismatched Braces or Brackets

7. Trying to Read Minified JSON

My Workflow

A Small Tool That Helps

Final Thoughts

Tags

5 Browser-Based Tools I Use Almost Every Day as a Developer

1. JSON Formatter & Validator

2. JWT Decoder & Validator

3. Regex Tester & Validator

4. SQL Formatter & Beautifier

5. QR Code Generator

Other Utilities I Frequently Use

Why I Prefer Browser-Based Tools

Why I Built ToolNudge: A Privacy-First Collection of Browser-Based Utilities

The Idea

What I've Built So Far

Lessons Learned

What's Next