DEV Community: Saurabh Kumar

I got tired of try/catch lying to me. So I built result.js.

Saurabh Kumar — Fri, 12 Jun 2026 05:32:28 +0000

You call JSON.parse. It looks safe. Nothing in the signature tells you otherwise.

Then someone passes garbage in production and your server crashes.

That's not a bug. That's try/catch being invisible.

The problem

function parseConfig(text: string): Config {
  return JSON.parse(text); // throws SyntaxError. you'd never know.
}

This function lies. It says it returns a Config. It doesn't say it might explode. TypeScript doesn't warn you. Your tests probably don't catch it. And the person calling this function has no idea they need to wrap it.

The failure is real. It's just hidden.

What if failure was part of the type?

function parseConfig(text: string): Result<Config, SyntaxError> {
  return wrap(() => JSON.parse(text));
}

Now the signature is honest. Two possible outcomes. Both visible. TypeScript knows about both. The person calling this function knows about both.

That's result.js.

The API

Two constructors:

const success = ok({ id: 1, name: "Alice" });
const failure = err({ code: 404, message: "Not found" });

Handle both outcomes with match — both arms required, TypeScript won't compile if you skip one:

result.match({
  ok:  user  => `Welcome, ${user.name}`,
  err: error => `Failed: ${error.message}`,
});

Chain fallible operations without nesting with flatMap:

const dashboard = getUser(id)
  .flatMap(user  => getPermissions(user))
  .flatMap(perms => buildDashboard(perms))
  .unwrapOr(emptyDashboard);

If any step fails, the rest are skipped. The error falls through to unwrapOr. No if (result.isErr()) checks stacking up.

Adopt existing throwing code at the boundary:

const parsed = wrap(
  () => JSON.parse(text) as Config,
  e  => ({ code: "PARSE_ERROR", detail: String(e) })
);

Async works too

ResultAsync wraps a Promise<Result<T, E>> and gives you the same chaining API. Write the whole pipeline, await once at the end.

const name = await ResultAsync
  .from(fetchUser(id), e => new ApiError(e))
  .flatMap(user => ResultAsync.from(fetchProfile(user.profileId), e => new ApiError(e)))
  .map(profile => profile.displayName)
  .unwrapOr("Anonymous");

No nested awaits. No growing stack of error checks. One await at the end.

When to use it

Use Result when the failure is an expected outcome — parsing input, querying a database, calling an API.

Stick with try/catch when the failure is a bug — out of memory, programmer errors, things that should never happen.

You don't have to pick one everywhere. wrap converts throwing code at the boundary so you can work with Result from there.

Install

npm install @bugfreedev/result.js

Zero dependencies. Full TypeScript. Ships with type declarations — no @types package needed.

import { ok, err, wrap, ResultAsync } from "@bugfreedev/result.js";
import type { Result } from "@bugfreedev/result.js";

The idea is simple: functions that can fail should say so. Not in a comment. Not in the docs. In the type signature, where TypeScript can see it and so can anyone reading the code.

That's the whole thing.

Links

If you try it, I'd love feedback on the API design, naming, and overall developer experience. The goal is to keep it small, obvious, and pleasant to use without turning it into a mini framework.

[Boost]

Saurabh Kumar — Mon, 16 Feb 2026 15:41:09 +0000

Something BIG is coming to Firechat 🔥

Saurabh Kumar ・ Feb 16

#webdev #chatapp #nextjs #announcement

Tell me something a fluent Pythonista doesn’t know 🐍

Saurabh Kumar — Sun, 14 Dec 2025 05:43:20 +0000

I’ve been working with Python for quite a while now and feel pretty fluent with it —

but let’s be honest… Python always has something up its sleeve 😄

So tell me 👇

A Python feature that surprised you
A weird quirk you discovered way too late
A clean trick you wish you’d known earlier
A “wait… Python can do that?” moment

No beginner stuff please 🫡

I’m genuinely curious to see what even experienced Pythonistas miss sometimes.

Drop your underrated Python knowledge below 🔥🐍

It’s been a week since I shared my chat app — and I’m trying to understand why it didn’t click

Saurabh Kumar — Sat, 13 Dec 2025 17:13:57 +0000

It’s been almost 7 days since I shared Firechat, a small chat app I built, and it hasn’t really gone anywhere.

Not ranting. Not upset. Just genuinely trying to understand why.

I originally built Firechat for my friends so we could chat privately without keeping message history. Over time, it slowly became a proper app, so I decided to share it publicly and see if others found it useful too.

Maybe the idea isn’t clear.

Maybe the UI isn’t interesting enough.

Maybe people just don’t need another chat app.

Or maybe I’m just bad at presenting it.

Here’s the app if you want to take a look:

👉 https://fyrechatz.vercel.app

And the source code is here:

👉 https://github.com/bug-free-dev/firechat

If you’ve built side projects before, I’d really appreciate honest feedback — even blunt feedback. “This already exists” or “I wouldn’t use this” is still helpful.

If you have thoughts, ideas, or suggestions on what could be better (or why this didn’t click at all), I’m all ears.

Thanks for reading 🙏

Still building. Still learning. 🔥

Tryyyy out Firechat!!

Saurabh Kumar — Sun, 07 Dec 2025 12:34:40 +0000

🔥 Firechat

Chat. Chill. Vanish. Repeat. 💨✨

🚀 Try the Live Demo

Connect with friends, talk freely, and watch your messages disappear like they never existed.

😄 Why Firechat Exists (True Story)

So here’s the lore.

I just wanted to chat peacefully with my bro.

But… his sister kept peeping into our chats.

And me being a highly introverted, slightly isolated kid, confrontation was NOT an option 😅

So instead of arguing, blocking, or crying internally, I did the most reasonable thing:

I built my own chat app.

That’s how Firechat was born 🔥

A place where messages disappear when the session ends —

no screenshots, no history, no “remember when you said that” trauma.

Simple problem. Slightly overkill solution. Totally worth it.

🌟 What is Firechat?

Firechat is a lightweight, real-time chat app made for:

students
friends
late-night talks
secret convos
and people who just want peace 😌

Messages vanish automatically when you leave.

No clutter. No noise. Just vibes.

Built originally just for fun…

then somehow turned into a full project I kept polishing because I got attached 🫶

✨ Features (aka cool stuff)

💬 Real-time chat (talk, not wait)
🔥 Ephemeral messages – messages disappear when the session ends
🎨 Clean & fun UI – minimal, smooth, and distraction-free
🎓 Made for students – by a student, for students
🙌 Kudos system – appreciate your friends with virtual rewards
⚡ Fast & lightweight – no unnecessary drama

🔐 Privacy First. Student Safe.

Firechat is private by design.

It’s made for students, by a student — so privacy actually matters here.

No permanent chat history
No awkward “wait… did I delete that?” moments
No stress if you accidentally forget to clear chats

Messages automatically disappear when the session ends.

So even if you forget to clear chats… Firechat already did it for you 😌💨

Basically:

Oops-proof chatting for students.

🧠 How it was built (without the boring part)

This project taught me a lot.

I explored ideas, tried things, broke stuff, fixed it again, and slowly shaped Firechat into what it is today.

Some tools helped along the way (you know… the smart kind 😉), but every decision, polish, and late-night tweak was hands-on learning.

It’s not perfect.

But it’s real.

And it works 🔥

🤝 Want to Help Build It?

Firechat is open source, and help is ALWAYS welcome 🙏

👉 Source Code:

https://github.com/bug-free-dev/firechat

You can help by:

🖼️ Adding media sharing (images, GIFs, attachments)
🎨 Improving UI / animations
⚡ Making things faster & smoother
🐛 Fixing bugs or cleaning code
💡 Suggesting fun ideas

Even small contributions matter a lot — PRs, issues, suggestions, anything 💜

(Also… I’m a bit busy these days, so help = instant good karma 😎

God might notice. No guarantees though.)

🔮 Future Ideas (aka “when motivation hits”)

🎨 Custom chat themes
📸 Image & media sharing
🔔 Notifications
🎮 Mini-games inside chat
✨ Even more playful UI

💜 Who is this for?

Firechat started as a student-to-student thing.

A safe, simple, and fun space to talk freely.

Now it’s for anyone who:

likes clean apps
enjoys building
or just wants messages to vanish dramatically 💨

🌱 A Small Request

If you:

tried the app
liked the idea
or laughed at the backstory

Consider ⭐ starring the repo or contributing something small.

It genuinely helps more than you think.

And if you don’t — no pressure 😄

Firechat will still vanish your messages either way.

🔥 Built for students

💬 Built for privacy

💨 Built to disappear

Ready to try it?

👉 Launch the Live Demo

Made with 💜, curiosity, and way too much caffeine

by a student who just wanted privacy.