DEV Community: Siddhesh Shirdhankar

I Built 1Note - A Secure Ephemeral Note Sharing Tool (and What It Taught Me)

Siddhesh Shirdhankar — Sat, 21 Mar 2026 13:59:08 +0000

Most developers have done this at least once:

Sent a password over Slack
Shared credentials in email
Copied secrets into a notes app and forgot about them

It works — until it doesn’t.

That’s where the idea for 1Note came from. It is a simple tool:

Share a secret → view it once → it disappears

Click here to checkout 1Note

What is 1Note?

1Note is a secure, ephemeral note-sharing tool designed for both quick use and developer workflows. You create a note, get a link, share it — and:

It can expire after one view
It can have a view limit
It can expire after time
It can be password-protected

No accounts. No friction.

The Problem I Wanted to Solve

We all share sensitive data in unsafe ways:

API keys
Database passwords
Tokens
Temporary credentials

Most tools don’t enforce ephemeral access. Once shared, the data lives forever. That’s the real problem.

Core Idea

Make secrets temporary by default instead of permanent unless deleted. That single shift changes how you think about sharing data.

How It Works (High Level)

Create Note
- User sends content
- Backend stores it securely
- Returns a unique link
Access Note
- User opens link
- System validates: Not expired, Not deleted, Within view limits
Consumption
- View count increments atomically
- If limit reached → note is destroyed

Security Model

1Note uses:

HTTPS (encryption in transit)
Encryption at rest (server-side)
Optional password protection
Rate limiting

[!IMPORTANT]
The current version uses server-side encryption, not zero-knowledge encryption. This was a conscious tradeoff to keep the system simple and usable.

The Hardest Part: Concurrency

One of the most interesting challenges was: How do you ensure a note is only consumed once?

Imagine two users opening the same link at the same time. To solve this, we use an atomic database operation:


sql
UPDATE SecureNote
SET viewCount = viewCount + 1
WHERE slug = $slug
AND (maxViews IS NULL OR viewCount < maxViews)
AND isDeleted = false
AND (expiresAt IS NULL OR expiresAt > now())
RETURNING *

Why hiding IDs wasn’t enough for secure share links

Siddhesh Shirdhankar — Fri, 16 Jan 2026 04:55:26 +0000

I recently went down a rabbit hole thinking about how secure share links are usually designed.

My first instinct was the obvious one: hash the internal ID, put it in the URL, resolve it on the backend. It works — until you start thinking about revocation, expiry, and access control.

What finally clicked for me was realizing that a shared link isn’t the resource itself, it’s permission to access the resource. Once I separated those two ideas and added an indirection layer (slug → resource), a lot of awkward edge cases disappeared.

I wrote a short reflection on this shift in thinking — not a tutorial, just a design lesson I learned the hard way:

👉 Building a Secure Sharing System: Why Slugs Matter More Than Hashes

Would love to hear how others have approached this problem.

Tab Wise v2.1.0 is live

Siddhesh Shirdhankar — Tue, 30 Dec 2025 06:50:57 +0000

Drowning in Tabs? Try This Chrome Extension

If your browser regularly looks like this:

“I’ll close these tabs later”
(opens 5 more)

—I built something for you.

🚀 Tab Wise v2.1.0

Tab Wise is a modern Chrome extension that helps you organize, search, and manage tabs without breaking your flow.

What it helps with:

🔍 Instantly search tabs by title or URL

🧩 Automatically group tabs (by domain, activity, time, or context)

🎨 Create custom groups with colors & favorites

⏱️ Track tab activity and identify stale tabs

🧠 Side panel UI that stays open while you browse

👉 Install Tab Wise (Free):
🔗 Chrome Web Store – Tab Wise

👋 Built by a tab-hoarder, for tab-hoarders

I built Tab Wise during a hackathon after failing to find a tab manager that felt fast, modern, and non-intrusive.
It’s privacy-first, lightweight, and stores everything locally.

If you’re curious about the build journey, tech stack, and lessons learned, I also wrote about it here:
📖 (https://medium.com/p/78100bc56348)

💬 Feedback welcome

Try the extension, break it, and tell me what you think.
If it saves you even one “where did that tab go?” moment, it’s done its job.

Let’s make tab chaos optional ✨

# 🧠 My First Online Hackathon Experience — How I Built InterviewCoach.AI

Siddhesh Shirdhankar — Sun, 09 Nov 2025 16:20:35 +0000

Just wrapped up my first ever online hackathon — Google Built-in AI Hackathon 2025, and it was an absolute rollercoaster 🎢

From late-night coding to last-minute demo edits, I learned more in 48 hours than I had in weeks.

Built InterviewCoach.AI, a Chrome extension powered by Gemini Nano + Gemini 2.5 Flash, that helps users analyze job descriptions, generate interview questions, record voice answers, and even craft cover letters.

I wrote about the full experience here 👇

👉 Read the full story on Medium

If you’re planning to participate in your first hackathon — or just curious how AI extensions come together — this might give you some inspiration ⚡

The REAL reason React apps slow down — and the 3 tools to fight it

Siddhesh Shirdhankar — Mon, 25 Aug 2025 08:14:35 +0000

React felt fast… until it didn’t.

Ever built a React app that was buttery smooth at first, but once your app grew, your UI suddenly lagged like an old laptop running 50 Chrome tabs?

That’s usually when people discover the "holy trinity" of React performance optimization:

React.memo

useCallback

useMemo

But here’s the truth:
👉 Most devs either overuse them or don’t actually know what’s happening under the hood.

I just finished writing an in-depth breakdown that goes beyond the usual surface-level definitions.
Instead of just “React.memo prevents unnecessary re-renders” 🙄, I dug into how React reconciles components, why references break equality checks, and when memoization actually helps vs hurts.

🔍 Covered in the guide:

What really happens during React’s reconciliation cycle.

Why useCallback/useMemo aren’t “free” optimizations.

Common pitfalls (like wrapping everything in memoization).

A mental model to know exactly when to use them — and when not to.

If you’ve ever wondered why your memoized code still re-renders or felt guilty sprinkling useMemo everywhere withoutunderstanding… this might help.

Would love feedback from the community:
👉 Do you consciously think about reconciliation & referential equality when optimizing?
👉 Or do you mostly rely on profiling after things feel slow?

Link to full write-up (if you want): Click Here

“Build Features, Not Folders”: Scalable React Architecture

Siddhesh Shirdhankar — Sun, 27 Jul 2025 07:47:29 +0000

🚨 Most frontend projects don’t fail because of bad code.

They fail because of chaotic structure. After working on real-world apps with growing teams and evolving features, I’ve realized:
_how you structure your project determines how fast (or slow) your team moves. _

That’s why I wrote this new article: 👉 “Build Features, Not Folders”: Scalable React Architecture for Frontend System Design Link

I go into: Why file-based routing isn’t enough for serious apps The power of feature-first thinking How to design folders that scale with your team A simple diagram that makes things click.

This is Week 1 of a new series I’m writing — designed to help frontend engineers write cleaner, more scalable code. 🧠 If you're building with React, Next.js, Remix or Expo — this is for you.

🔖 Topics: #React #FrontendDevelopment #SoftwareArchitecture #WebDev #CleanCode Let me know your thoughts — and feel free to share how your team structures projects!