Forem: Naimur Rahman

I built Supatab: Chat with your Chrome tabs like ChatGPT

Naimur Rahman — Sat, 31 May 2025 08:00:00 +0000

As a developer, I’m often jumping between 10 or more tabs—reading docs, blog posts, GitHub issues, comparing tools, or just trying to figure something out. I realized I was wasting a lot of time switching back and forth, trying to remember where I saw something or copy-pasting between tabs. It was just getting in the way of getting things done.

So I asked myself:
What if I could just talk to my tabs and ask questions — like ChatGPT, but for my browser?

That’s how Supatab was born.

What Supatab does
Supatab is a Chrome extension that lets you:
• Chat with any open tab as if it were an AI assistant
• Summarize long articles, docs, or reports instantly
• Ask specific questions and get relevant answers without re-reading everything
• Extract key points from dense pages
• Stay focused without switching tabs constantly

It’s like having a mini ChatGPT for every tab you’re working with.

Why I built it
I initially built this just for myself — to speed up how I understand product requirements, technical articles, or explore new APIs. But after sharing it with a few friends, I realized other devs were facing the same struggles.

So I decided to polish it a bit and launch it publicly.

Want to give it a try?
Supatab is free, and I’d really love to hear what you think. You can install the extension here and check it out. If you find it helpful, I’d really appreciate your support on Product Hunt. An upvote would mean a lot and help get Supatab in front of more people who might benefit from it too.

BroadcastChannel API: Sending Messages Between Tabs

Naimur Rahman — Wed, 06 Sep 2023 17:22:28 +0000

Why Tab Communication in Web Browser Matters

Communicating between different tabs or windows in a web browser is super important for many reasons. Imagine you have several open tabs while shopping online. You put an item in your cart in one tab, and you want all the other tabs to know about it instantly. That's one of the reasons we need this kind of communication. Also, think about logging into a website like your bank account. If we log out in one tab, we'd want to be logged out in all the other tabs, too to keep everything safe. It's like making sure you lock all the doors when leaving your house. So, it's not just convenient; it also makes the web safer and more efficient for us.

What is the Broadcast Channel API?

The Broadcast Channel API is like a special communication tool for web browsers. It allows different tabs or windows in our browser to talk to each other. It's a way for them to share information instantly. Think of it as a secret chat system just for our browser. It helps web apps work together and stay in sync, making our online experience smoother.

How Broadcast Channel API works

Here's how it works in simple terms:

Create a Channel: We create a channel with a specific name, like cart_channel
Send Messages: In one tab, we can send a message (like "I added a new item to the cart!") to the cart_channel
Other Tabs Listen: All the other open tabs also tuned into the cart_channel can hear this message.
Instant Updates: So, when we add something to our cart in one tab, all the other tabs can instantly update to show the same thing. It's like magic!

To implement Broadcast Channel API in your application read the full article here 👉 https://naimur.dev/broadcastchannel-api

Building Offline-Ready Webpage with Service Worker and Cache Storage

Naimur Rahman — Fri, 01 Sep 2023 19:40:52 +0000

Why We Need Offline Web Pages

Sometimes, our internet connection isn't reliable or completely absent. In those moments, we still want to use websites and apps. This is where offline web pages come in handy. They allow us to access content even when we're not online.

Introducing Service Workers and Cache Storage

Service Workers are like web helpers. It work behind the scenes to make offline web pages possible. It can save website stuff (like pictures, fonts and other assets) on our device so we can see them even without the internet. It also control what our web page does when it's online.

Cache Storage is like a storage room for web things. It keeps all the website stuff we might need, organised neatly. Service Workers can go there and grab what's needed for page to load offline. So, when we're not online, we still get to see and use web pages.

Let's explore how to make a webpage available offline by doing some simple coding. We'll save an HTML file and an image so that users can still see them, even when they are not connected to the internet.

Step 1: Getting Started
First, Let's create a folder for our project and put main HTML file index.html and the image we want to use cat.jpeg inside it.

Step 2: Registering the Service Worker
Now, let's register the Service Worker in index.html file. Place the following code:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>
  <body>
    <h1>Hi There!</h1>

    <img src="./cat.jpeg" width="300" height="300" />

    <script>
      async function registerServiceWorker() {
        if ("serviceWorker" in navigator) {
          try {
            const registration = await navigator.serviceWorker.register(
              "sw.js"
            );
            console.log(
              "Service Worker registered with scope:",
              registration.scope
            );
          } catch (error) {
            console.error("Service Worker registration failed:", error);
          }
        }
      }

      registerServiceWorker();
    </script>
  </body>
</html>

In this code we check if the browser supports Service Workers.

Step 3: Writing the Service Worker Code
Now, let's create a JavaScript file called sw.js in project folder. This file will contain the code for Service Worker.

const cacheName = "offline-cache-v1";
const cacheUrls = ["index.html", "cat.jpeg"];

// Installing the Service Worker
self.addEventListener("install", async (event) => {
  try {
    const cache = await caches.open(cacheName);
    await cache.addAll(cacheUrls);
  } catch (error) {
    console.error("Service Worker installation failed:", error);
  }
});

// Fetching resources
self.addEventListener("fetch", (event) => {
  event.respondWith(
    (async () => {
      const cache = await caches.open(cacheName);

      try {
        const cachedResponse = await cache.match(event.request);
        if (cachedResponse) {
          console.log("cachedResponse: ", event.request.url);
          return cachedResponse;
        }

        const fetchResponse = await fetch(event.request);
        if (fetchResponse) {
          console.log("fetchResponse: ", event.request.url);
          await cache.put(event.request, fetchResponse.clone());
          return fetchResponse;
        }
      } catch (error) {
        console.log("Fetch failed: ", error);
        const cachedResponse = await cache.match("index.html");
        return cachedResponse;
      }
    })()
  );
});

THere's what's happening in the code:

We give a name to our cache (cacheName) and list the URLs (cacheUrls) we want to store for offline use.
In the "install" part, we prepare our cache and add the URLs to it.
We open the cache and attempt to match the request with the cached responses.
If a cached response is found, it's returned. If not, we fetch the resource from the network, cache it for future use, and return the network response.
In case of any errors during the fetch process, we handle it by returning a cached version of "index.html" to ensure the user still sees something.

Step 4: Testing our Offline-Friendly webpage
To check if the page works offline:

Open the page while the device is online to make sure it loads correctly, including the image.
Disconnect from the internet (turn off Wi-Fi or unplug network cable).
Reload the page. We should still see the page, including the image, even though there's no internet.

We can also test from the chrome browser, here's the steps:

Open the page while the device is online
Open devtools in chrome browser and go to the Application tab
Click on Service Workers from the sidebar and check the Offline option
Reload the page and we can see the contents loading offline

We've now created a webpage that can work offline using Service Workers. This technique can be expanded to store more things and make websites robust even when there's no internet.

Full Code 👉 https://github.com/nsourov/offline-web-page