DEV Community: Aditya Sorathiya

I added an interactive dashboard to the PasteDB CLI — manage pastes from your terminal

Aditya Sorathiya — Mon, 17 Aug 2026 14:40:05 +0000

PasteDB CLI

just got a new interactive dashboard! 🚀 Browse, navigate, open, delete, and refresh your pastes directly from the terminal — without constantly switching to the browser.

I've been working on PasteDB, a paste-sharing platform for code, notes, text, and more.

Today I added something I've wanted in the CLI for a while:

🗂️ An interactive paste dashboard — directly in the terminal

Instead of running separate commands every time I want to manage a paste, I can now run:

pdb pastes

and get an interactive dashboard showing my pastes.

It looks something like this:

╭──────────────────────────────────────────────────────────────╮
│                         PasteDB                              │
│                       Your Pastes                            │
╰──────────────────────────────────────────────────────────────╯

  3 pastes

  ❯ app.py
      ID:       abc123
      Language: python
      Preview:  print("Hello from PasteDB!")

    website.html
      ID:       xyz789
      Language: html
      Preview:  <!DOCTYPE html>...

    notes.md
      ID:       note456
      Language: markdown
      Preview:  My project notes...

──────────────────────────────────────────────────────────────
↑ ↓ Navigate   O Open   d Delete   r Refresh   q Quit

What can it do?

⬆️⬇️ Navigate through your pastes

🌐 Open the selected paste in your browser

🗑️ Delete a paste directly from the dashboard

🔄 Refresh the list without restarting the CLI

🔐 Handle encrypted/private paste data without dumping the encrypted objects into the terminal

📋 Show useful information such as the paste ID, language, title, and preview

The goal is to make the CLI feel less like a collection of commands and more like a small terminal application.

Why did I add this?

Previously, managing several pastes from the CLI meant remembering individual commands and paste IDs.

Now I can simply run:

pdb pastes

and navigate through everything from one place.

I'm still improving it. I initially experimented with adding search to the dashboard, but I've temporarily removed it while I work on making the handling of encrypted/private pastes more robust.

PasteDB CLI is built with Node.js and is available on npm.

If you're interested in trying it:

npm install -g pastedb-cli

Then:

pdb auth
pdb pastes

I'd love to hear what other features would make a terminal-based paste manager more useful.

Want to view Docs?See them here
https://pastedb.netlify.app/cli
Source Code:
https://github.com/sorathiya903/pastedb-cli
NPM JS : https://www.npmjs.com/package/pastedb-cli

I Built PasteDB CLI in 1 Day — Upload Files to the Web with pdb create 🚀

Aditya Sorathiya — Fri, 14 Aug 2026 13:20:33 +0000

Want to do this?

pdb create app.py

…and have your file uploaded online with a shareable PasteDB link returned instantly?

Now it's possible. 🚀

I built PasteDB CLI in just 1 day — a lightweight command-line tool for developers to upload files, retrieve pastes, update them, delete them, explore public pastes, and manage API keys without leaving the terminal.

The CLI is built with JavaScript / Node.js and connects directly to the PasteDB API.

⚡ What it can do

pdb create app.py

Upload a local file and get a PasteDB link.

pdb get abc123

Fetch a paste directly from the terminal.

pdb update abc123 app.py

Update an existing paste.

pdb delete abc123

Delete a paste.

It also includes API-key authentication, public paste exploration, code execution support, and other developer-focused commands.

🛠 Tech Stack
JavaScript / Node.js
The goal was to keep the CLI simple, fast, and easy to use while making PasteDB accessible directly from the terminal.

🔗 Check it out
Source code: https://github.com/sorathiya903/pastedb-cli
CLI documentation: https://pastedb.netlify.app/cli

This was a one-day build, and I'm planning to keep improving the CLI with more developer-friendly features.
What would you want to see added to a my pastebin CLI? 👀

I removed live cursors from PasteDB — and replaced them with line-level editing presence

Aditya Sorathiya — Wed, 12 Aug 2026 16:04:10 +0000

I recently made a small but important change to PasteDB's collaborative editor.

Previously, PasteDB showed live cursors for other users while they were editing. While this was useful, I found that multiple cursors could make the editor feel cluttered, especially when several people were working at the same time.

So I removed the live cursor UI and replaced it with a simpler line-level editing indicator.
Now, when another user is editing a line:

A small colored dot appears in the editor gutter.
The dot shows exactly which line the user is working on.
Hovering over the dot reveals the user's name.
The indicator stays out of the code itself, keeping the editor cleaner.
Multiple users can be shown editing different lines at the same time.

The goal was to make collaboration feel less distracting while still letting everyone know what others are working on.

Try PasteDB

You can try the collaborative editor and other PasteDB features here:

Try PasteDB →
https://pastedb.netlify.app/

I'd love to know which approach you prefer for collaborative editors: live cursors or lightweight line-level presence?

Samsung users, want to use AirDrop? Here it is

Aditya Sorathiya — Sun, 09 Aug 2026 14:33:10 +0000

Apple spent a decade and billions of dollars trapping users in their closed ecosystem using hardware-restricted features like AirDrop. If you use a Samsung phone and a Windows laptop, you are traditionally left completely out in the cold

The Disruption: I completely democratized local mesh sharing. PasteDB’s Nearby Transfer doesn’t care about your hardware, your operating system, or your brand. Because it runs natively inside his hyper-optimized single-stream HTML web view, a Samsung phone can "AirDrop" complex code snippets, scripts, or markdown documents straight to an ancient Linux laptop or an iPad instantly. I bypassed Apple's massive hardware wall with a few lines of clean, asynchronous Python and JavaScript.

Try to send : https://pastedb.netlify.app/paste/guide

Go to it (Sender)
Click the Nearby Transfer Button
Modal will open
For receivers
Go to
https://pastedb.netlify.app/Transfer

Follow the instructions

Your device will be visible on the sender modal
Click the device
Transfer Complete

A Big Day Building Real-Time Collaboration for PasteDB 🚀

Aditya Sorathiya — Sun, 09 Aug 2026 10:36:38 +0000

Today I made a lot of progress on PasteDB's real-time collaboration system.
PasteDB can now:
⚡ Sync edits between collaborators in real time
👥 Show who is currently in the workspace
🔐 Handle join requests
✅ Let the host approve or reject users
🧑‍💻 Support editor and viewer roles
🔄 Synchronize the current document when someone joins
💾 Save the collaborative document back to PasteDB
I'm now working on live cursors, so collaborators can see exactly where other people are editing.
This is currently the hardest part. I'm using Yjs relative positions to keep cursor locations tied to the collaborative document, but synchronization timing can sometimes cause a remote cursor position to fail to resolve or become inaccurate.
Still debugging it, but the collaboration system is starting to feel like a real collaborative editor rather than just a normal paste editor.
A lot accomplished today. More to come 🚀

I’m Building Real-Time Collaboration for PasteDB — Live Editing, Presence & Access Control

Aditya Sorathiya — Sun, 09 Aug 2026 10:34:10 +0000

I’m currently working on collaboration features for PasteDB.
The goal is to turn PasteDB’s editor into a real-time collaborative workspace where multiple people can work on the same paste together.

So far, I’ve implemented:

⚡ Live updates — edits made by one user appear in other users’ editors in real time.
👥 Participant presence — users can see who is currently in the collaboration session.
🔐 Join requests — users can request access to a workspace.
✅ Host approval/rejection — the host can approve or reject incoming users.
📝 Editor/viewer roles — users can join with different permissions.
🔄 Yjs-based synchronization — using Yjs to handle collaborative document updates.

The next feature I’m working on is live cursors — showing exactly where other collaborators are editing.

And honestly, this is currently the part giving me trouble 😅. I’m dealing with cursor position mapping, Yjs relative positions, and synchronization timing. Sometimes a cursor can’t be resolved correctly when updates arrive out of order.
Still working on it and learning a lot along the way.

PasteDB collaboration is slowly coming together 🚀

I’ll share more updates as I get the cursor synchronization working.

Want to view?
Here : https://pastedb.netlify.app

PasteDB now has Version Control — Keep up to 10 versions of your pastes

Aditya Sorathiya — Fri, 07 Aug 2026 15:52:19 +0000

Version Control is now available in PasteDB 🚀

I've added a Version Control feature to PasteDB that makes it easier to keep track of changes made to a paste.

Instead of losing the previous content whenever you update a paste, PasteDB can now keep previous versions so you can look back at how your paste changed over time.

How it works

Each saved change can create a new version.
PasteDB stores up to 10 versions for a paste.
Versions are kept in chronological order.
When you try to save an 11th version, the oldest version is automatically deleted.
This keeps the version history limited to the latest 10 versions.

For example:

Version 1
Version 2
Version 3
...
Version 10

After creating Version 11:

Version 2
Version 3
Version 4
...
Version 11

So the history always contains the 10 most recent versions.

Why I added it

Sometimes you make a change to a paste and later realize that an earlier version was better.

Version Control gives you a way to keep those previous states without having to manually save copies of the paste.

I'm also working on more features around PasteDB's editing and collaboration capabilities, so version history is becoming an important part of the project.

What do you think would be useful to add next to version control?

Try here : https://pastedb.netlify.app/create

How I Built PasteDB in 3 Months — From a Blank Repo to a Real Product

Aditya Sorathiya — Tue, 04 Aug 2026 09:49:37 +0000

How I Built PasteDB in 3 Months — From a Blank Repo to a Real Product

A developer recently asked me:

«“How do you manage all of this so effectively?”»

It made me think about how PasteDB actually started.

Not with a big team.

Not with expensive infrastructure.

Just a blank GitHub repository, an idea, and a lot of questions.

May 2, 2026 — The beginning

I wanted to build a project that could give me real-world experience and, hopefully, real users.

At first I thought about building something much bigger, like a social media platform.

Then I started thinking about something simpler: code and information sharing.

I noticed that many paste-sharing platforms had trade-offs.

If something was simple, it wasn't always secure.

If it focused heavily on security, the experience wasn't always great.

And if it tried to include everything, the interface could become complicated.

So I decided to build my own.

I created the PasteDB repository on May 2.

The first commit was basically just the initial README.

And I remember thinking:

Will I actually be able to build this?

Will anyone use it?

What happens if nobody does?

Building the MVP

The first version was extremely simple.

The project started with:

HTML/CSS/JavaScript
FastAPI
MongoDB Atlas

I created the initial frontend and backend and slowly started turning the idea into an actual product.

Within a couple of days, the tiny "create.html" file had grown from almost nothing to 100+ of lines.
And now 4000+ lines

Then came authentication.

I decided to keep registration simple with Google authentication.

Getting that working wasn't exactly painless, but eventually I had a functional dashboard and a working authentication flow.

At that point, I thought:

Maybe I actually have an MVP.

Then I stopped.

On May 18, I stopped working on PasteDB.

I started working on other projects and even stopped maintaining the backend server.

For a while, I genuinely thought:

PasteDB failed.

I didn't think there was much more I could do with it.

June 10 — Starting again

Then I wanted to participate in a hackathon.

I came back to PasteDB.

And that changed everything.

I started improving the project again.

I worked on SEO.

I submitted pages for indexing.

I started trying different communities.

I didn't have money for a custom domain, so I kept using:

https://pastedb.netlify.app

I wasn't trying to make it look like a huge startup.

I just wanted the product to work.

I tried Reddit.

Some posts were removed by moderators.

So I tried DEV.

And DEV was different.

People started following me.

People started asking about PasteDB.

People actually started noticing the project.

Then I stopped focusing only on code.

This was probably one of the biggest lessons.

Building features is important.

But nobody can use a product they don't know exists.

So I started spending more time on:

SEO
developer communities
documentation
demos
feedback
talking to developers
finding ways for PasteDB to integrate with other tools

I also added Google Analytics so I could actually understand whether people were using the product.

Then something happened that made all the work feel real.

July 22 — 6:30 PM

I opened Analytics.

98 active users.

98 new users.

Only two users away from 100.

And there were returning users too.

People were actually finding something I had built.

Users were coming from different parts of the world, with a large portion coming from the US.

That was a completely different feeling from looking at an empty project.

But there was another challenge: resources.

I didn't have a powerful development machine.

The PasteDB web interface and SDK were largely developed on a Samsung Galaxy M21(Whose screen is bleeding).

The VS Code extension was developed on an old Dell Inspiron N5010 with an i3 processor and a hard drive.

So yes, a significant part of PasteDB was built from a phone.

Today PasteDB has grown beyond the original MVP.

It now includes:

Web interface
Python and Node.js SDK
VS Code extension
API key management
Public and private pastes
Custom URLs
Image support
Analytics and view tracking
Google Authentication
Syntax highlighting
Version Control
QR sharing
Transfer tools
End-to-end encryption features
And more

There are still things I want to improve.

But at some point, you have to stop saying:

“It's not finished yet.”

and start saying:

“This is good enough to put in front of people.”

And that's what I learned.

PasteDB wasn't built in one continuous sprint.

It was:

Idea → Build → Stop → Restart → Improve → Ship → Get feedback → Market → Repeat.

I didn't have a perfect plan.

I didn't know if anyone would use it.

I didn't have expensive hardware.

I didn't have a team.

I just kept trying different things.

And one of the most important lessons I've learned is that marketing isn't only posting advertisements.

Sometimes marketing is:

using another developer's product,
finding a bug,
reporting it,
giving useful feedback,
starting a genuine conversation,
and showing what you've built.

That can lead to opportunities you never planned for.

That's actually how some of my recent developer conversations started — including conversations that eventually led to PasteDB integrations.

So when someone asks me:

“How do you manage all of this?”

My answer is probably:

I don't manage everything perfectly.

I just keep moving.

Build something.

Put it in front of people.

Listen.

Improve it.

And repeat.

That's how PasteDB went from a blank repository on May 2 to a real product being used, discussed, and integrated with other developer tools.

And I'm still building.

PasteDB: Share code, notes, snippets and images instantly.

I documented the full development journey, including the milestones, setbacks, technical decisions and lessons learned, on the PasteDB About page.

🚀 PasteDB is now on AlternativeTo!

Aditya Sorathiya — Tue, 28 Jul 2026 13:19:43 +0000

PasteDB is a modern paste-sharing platform built for developers. Share code, notes, logs, markdown, links, and images with ease. Features include public and private pastes, end-to-end encrypted (E2EE) sharing, syntax highlighting, custom URLs, Burn After Read, QR code sharing, Nearby Transfer, Markdown preview, an Explore page, REST API, Python SDK, VS Code extension, and API key management. Fast, privacy-focused, and designed to simplify sharing and collaboration.

I got approval on 27 July 26

See on AlternativeTo : https://alternativeto.net/software/pastedb/about/

https://alternativeto.net/software/pastedb

Why I Keep My Frontend and Backend Separate (Even in the Same Repository)

Aditya Sorathiya — Sun, 26 Jul 2026 09:10:57 +0000

When I started building web applications, I quickly realised that keeping the frontend and backend as separate applications made development much easier.

My current setup looks like this:

project/
│
├── frontend/
│   ├── index.html
│   ├── config.js
│   ├── script.js
│   └── ...
│
├── backend/
│   ├── main.py
│   ├── auth.py
│   ├── ....
│   └── ...
│
└── README.md

I still keep everything in one Git repository, but the frontend and backend are deployed independently.

1.Frontend

HTML, CSS and JavaScript
Hosted on Netlify

2.Backend

FastAPI
Hosted on Render

3.Database

MongoDB Atlas

Why this works well

Independent deployments

If I update the UI, I only redeploy Netlify.

If I add a new API endpoint, I only redeploy Render.

Neither deployment affects the other.

Cleaner codebase

The frontend focuses only on:

User interface

API requests

Client-side logic

The backend focuses only on:

Authentication

Database operations

Business logic

Security

Each application has a single responsibility.

Better security

Database credentials and secrets stay in the backend.

The frontend never contains:

MongoDB URI

API keys

Secret tokens

Instead, it communicates with the backend through HTTP requests.

Easier maintenance

When a bug appears, I immediately know where to look.

UI bug? → Frontend.

Database bug? → Backend.

Authentication bug? → Backend.

Easy hosting

Using different platforms allows each service to do what it does best.

Netlify serves static files quickly through its CDN.

Render runs the FastAPI server.

MongoDB Atlas manages the database.

Each service specialises in its own task.

Do you need separate repositories?

Not necessarily.

For solo developers and small teams, a single repository with separate frontend and backend folders is often a great choice. It keeps everything together while still maintaining a clear separation of concerns.

As projects grow, some teams move to separate repositories, while others continue using a monorepo. Both approaches can work well—the important part is keeping the frontend and backend independent enough that they can be developed and deployed separately.

I Built a Paste Tool That Never Stores Your Data on a Server

Aditya Sorathiya — Fri, 24 Jul 2026 14:37:54 +0000

Most paste services upload your content to a server before giving you a shareable link.

I wanted something simpler for sharing sensitive information like passwords, Wi-Fi credentials, recovery codes, or short private notes.
So I built Link Paste.

How it works
🔗 Your entire paste is stored inside the URL.
🚫 Nothing is uploaded or saved on any server.
⚡ The link is generated instantly in your browser.
🔒 No link = no access to the data.
🗑️ Lose the link = the data is gone forever.

Since there's no database, there are no server-side copies to delete, leak, or expire.
It's best suited for:

Passwords
Wi-Fi credentials
Recovery codes
Temporary secrets
Short private notes ("shower thoughts" or reminders)

This isn't intended for large files or permanent storage—it's designed for quick, private sharing without relying on a backend.
I'd love feedback on the idea and suggestions for improving it.

👉 Try it here: https://pastedb.netlify.app/newLink

To Instant share Long Links, QR code is provided

To scan QR, go to https://pastedb.netlify.app/scan

For more features
https://pastedb.netlify.app

I Built a Tool That Lets Teachers Write Once and Teach Every Class

Aditya Sorathiya — Thu, 23 Jul 2026 09:39:26 +0000

Every day, teachers repeat the same process.
They solve a math problem on the board for one class, erase it, then rewrite the exact same solution for the next section. The explanation changes, but the writing doesn't.
While building PasteDB, I started wondering:
What if teachers only had to write it once?
The idea is simple:
Write the solution on the board once.
Capture it as an image or digital note.
Upload it.
Open the same page in every classroom using the projector.
Spend time explaining instead of rewriting.
I'm exploring how a developer-focused paste sharing platform can also become a lightweight classroom teaching tool.
I'd love feedback from teachers and developers—would something like this actually be useful?
See here https://pastedb.netlify.app