DeepakNess - Blog

Self-hosting FreshRSS on a Raspberry Pi device

2026-03-09T00:18:03Z

I love RSS/Atom and am subscribed to at least 75 feeds via the NetNewsWire app on my macOS laptop. While the app works great, sometimes, I want to read blogs on my phone too and my current setup didn't allow that. I was thinking to solve this for me for a long time, and finally got the idea and time to build a better reading setup when I learned about FreshRSS and that it can also be self-hosted.

Initially, I was ready to self-host this on a tiny VPS, but then I decided to use the tiny Raspberry Pi 4B with 1GB RAM that I had. Now that the setup is ready and I am already using it, it only consumes <250MB of RAM on the Pi device.

In this post, I will note down the whole installation process and my experience at the end:

1. Installing Docker

Docker made the process of installing and maintaining FreshRSS easier, and it was also the recommended way to install the app.

I, first, connected to my Pi device from my macOS laptop via SSH and then ran the following commands to install and start Docker.

# Refresh package lists
sudo apt update

# Install Docker engine + CLI + Compose
sudo apt install -y docker.io docker-cli docker-compose

# Start Docker now and on boot
sudo systemctl enable --now docker

# Test iif everything is working
docker --version
docker compose version
sudo docker run hello-world

Earlier, my device was using ~100MB of RAM when it had nothing installed, and now it was using ~180-ish MB of RAM.

2. Installing FreshRSS on the Pi

As Docker was ready, I proceeded with installing the FreshRSS app.

First, created a new folder in the root called freshrss and a few subfolders by running the following command:

# Create a new folder and subfolders
mkdir -p ~/freshrss/data ~/freshrss/extensions

# Go into the newly created folder
cd ~/freshrss

Created the compose.yaml file in the freshrss directory with the following content. I used the nano compose.yaml command to create the file, and then pasted the following:

services:
  freshrss:
    image: freshrss/freshrss:latest
    container_name: freshrss
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:80"
    environment:
      TZ: Asia/Kolkata
      CRON_MIN: "13,43"
    volumes:
      - ./data:/var/www/FreshRSS/data
      - ./extensions:/var/www/FreshRSS/extensions
    healthcheck:
      test: ["CMD", "cli/health.php"]
      interval: 75s
      timeout: 10s
      retries: 3
      start_period: 60s

You might need to modify the TZ (timezone) value, as per your location. And then started the container:

# Start the docker container
sudo docker compose up -d

# Check status using these commands
sudo docker compose ps

If everything works, exit using ctrl + c.

Now, the app is ready and running at the port 8080, but you can't access it from your different devices yet. From here, you have 2 options:

Use Tailscale on all your devices to access
Expose the app to the internet using Cloudflare Tunnel

From the security and ease-of-setup point of view, the #1 method is the best here. But I also wanted to give access to the feed reader app to my friend, so I went with the #2 option.

I will explain the Cloudflare Tunnel method here.

3. Exposing the app to the public internet

First, I needed to install cloudflared on my Pi, so I ran following commands one by one:

sudo mkdir -p --mode=0755 /usr/share/keyrings
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null

echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main' | \
  sudo tee /etc/apt/sources.list.d/cloudflared.list

sudo apt update
sudo apt install -y cloudflared

I also had to sign up to my Cloudflare account, go to Networking > Tunnels section, and create a Tunnel. Just gave the tunnel a name, and it gave me a command like below that I ran on the Pi:

# Connect to the Cloudflare dashboard
sudo cloudflared service install a_very_long_string_here

# Keep the tunnel running
sudo systemctl enable --now cloudflared

After this I added a destination subdomain, and then added http://localhost:8080 as the service URL, and the app was live.

I opened the destination subdomain I set up in the browser, and FreshRSS installation checklist was shown, then it asked me to sign up for the admin account, and I was in. I tried adding an RSS feed for testing, and it was working.

4. Importing my reading list and final look

I maintain this blogroll page on my website, so I added these feeds to the app. And then I also imported a .opml file shared by Andrej Karpathy earlier, it contained 90+ RSS/Atom feeds of most popular blogs on HackerNews.

I probably don't need all these, but as I spend more time reading, I will slowly keep unsubscribing to the feeds where the content is not relevant to me.

Apart from this, I also did a bit of customizations from the settings, and below is the final look for the reader. The sidebar can be toggled off, so the overall look is cleaner.

Initially, it required getting used to the UI as I have only used NetNewsWire previously and that is simpler to use. But now I like this as well, and have already been using it for a few days.

How the Raspberry Pi 4B is performing

The Pi device is performing surprisingly well. Currently, me and friend both are using the self-hosted RSS reader, and it doesn't even lag or slow down, even for a bit. And still only uses less than 250 MB of RAM, sometimes, even less than 200 MB, as you see below:

I am not on an extremely fast but on a 200 Mbps fiber internet connection (I mean, people already moved to Gbps, right?), and loading is still very fast – faster than many managed RSS reader web-apps I have tried.

Also, earlier, I had the Pi device connected to a power adapter via a type-c cable. But then I noticed a USB port on my WiFi router and connected to it, and now it takes the power from the router itself, as you see in the photo above.

What I like about FreshRSS

Some things I love about the open-source FreshRSS app are:

It fetches feed updates on the server-side in the background, so I don't have to wait for 2 minutes for all 90 feeds to get refreshed. When I open the public URL in the browser, it's ready for me to read as new updates are already fetched.
When you mark a post as favorite, it's permanently saved in the SQLite database it uses. Even if the original version is deleted, you still have the locally saved version.

FreshRSS has tons of options that I am still exploring and learning about, and will keep this page updated as I discover more noteworthy things.

How I Sync Mastodon Posts with My 11ty Blog

2026-02-06T16:52:48Z

I don't have a comment system on my blog, so I started adding this comment via email almost a year ago, and received a lot of heartwarming replies through that option. But not everyone wants to email you, so I recently also started adding this "Comment on Mastodon" feature below my blog posts (along with webmentions).

Typically, here's the process that I would follow:

Publish a blog post
Share it on Mastodon, and
Add Mastodon post link in Markdown frontmatter

When you add the mastodon YAML frontmatter in a post, the "Comment on Mastodon" option automatically starts showing below the post. Here's what the frontmatter looks like:

---
date: 2025-01-01
title: "title"
description: "description"
tags:
- tag-one
---

But... it's a tedious process to manually do it each time, isn't it?

I wanted something semi-automated, and I have finally put together a workflow that works for me.

I publish a blog post.
It's automatically published to Mastodon, Threads, and Bluesky via n8n by using Typefully API (see how it's done).
Run a script to auto-fetch, find your Mastodon posts with your blog URLs and update the frontmatter.

I already use Typefully to schedule my posts on social media, so it's not an additional purchase for me. But you can automate publishing to Mastodon directly via their API.

I am going to paste the entire script that I use for this, you can save it inside, say, /scripts/mastodon.js file.

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const ROOT_DIR = path.resolve(__dirname, '..');
const CONTENT_DIR = path.join(ROOT_DIR, 'content');

const MASTODON_INSTANCE = 'https://mastodon.social';
const MASTODON_USERNAME = 'deepakness';
const BLOG_DOMAIN = 'deepakness.com';

const DRY_RUN = process.argv.includes('--dry-run');
const FORCE = process.argv.includes('--force');

// Fetch account ID from username
async function fetchAccountId() {
  const url = `${MASTODON_INSTANCE}/api/v1/accounts/lookup?acct=${MASTODON_USERNAME}`;
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`Failed to fetch account: ${response.status}`);
  }
  const account = await response.json();
  return account.id;
}

// Fetch all statuses with pagination
async function fetchAllStatuses(accountId) {
  const statuses = [];
  let maxId = null;
  let page = 1;

  while (true) {
    const url = new URL(`${MASTODON_INSTANCE}/api/v1/accounts/${accountId}/statuses`);
    url.searchParams.set('limit', '40');
    url.searchParams.set('exclude_reblogs', 'true');
    if (maxId) {
      url.searchParams.set('max_id', maxId);
    }

    console.log(`Fetching page ${page}...`);
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`Failed to fetch statuses: ${response.status}`);
    }

    const batch = await response.json();
    if (batch.length === 0) break;

    statuses.push(...batch);
    maxId = batch[batch.length - 1].id;
    page++;

    // Small delay to be nice to the API
    await new Promise(resolve => setTimeout(resolve, 100));
  }

  return statuses;
}

// Extract links from HTML content using regex
function extractLinksFromHtml(html) {
  const links = [];
  const regex = /href="([^"]+)"/g;
  let match;
  while ((match = regex.exec(html)) !== null) {
    links.push(match[1]);
  }
  return links;
}

// Parse deepakness.com URL and extract type (blog/raw) and slug
function parseDeepakNessUrl(url) {
  try {
    const parsed = new URL(url);
    if (parsed.hostname !== BLOG_DOMAIN && parsed.hostname !== `www.${BLOG_DOMAIN}`) {
      return null;
    }

    // Match /blog/slug or /raw/slug
    const match = parsed.pathname.match(/^\/(blog|raw)\/([^/]+)\/?$/);
    if (match) {
      return { type: match[1], slug: match[2] };
    }
    return null;
  } catch {
    return null;
  }
}

// Find markdown file for a given type and slug
function findMarkdownFile(type, slug) {
  const possiblePaths = [
    path.join(CONTENT_DIR, type, slug, 'index.md'),
    path.join(CONTENT_DIR, type, `${slug}.md`),
  ];

  for (const filePath of possiblePaths) {
    if (fs.existsSync(filePath)) {
      return filePath;
    }
  }
  return null;
}

// Check if frontmatter already has mastodon field
function hasMastodonField(content) {
  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
  if (!frontmatterMatch) return false;
  return /^mastodon:/m.test(frontmatterMatch[1]);
}

// Insert mastodon field into frontmatter
function insertMastodonField(content, mastodonUrl) {
  // Insert after the opening ---
  return content.replace(/^---\n/, `---\nmastodon: "${mastodonUrl}"\n`);
}

// Scan content directories and find files (optionally only those missing mastodon field)
function findContentFiles(onlyMissing = true) {
  const files = [];
  const contentTypes = ['blog', 'raw'];

  for (const type of contentTypes) {
    const typeDir = path.join(CONTENT_DIR, type);
    if (!fs.existsSync(typeDir)) continue;

    const entries = fs.readdirSync(typeDir, { withFileTypes: true });
    for (const entry of entries) {
      let filePath;
      if (entry.isDirectory()) {
        filePath = path.join(typeDir, entry.name, 'index.md');
      } else if (entry.name.endsWith('.md')) {
        filePath = path.join(typeDir, entry.name);
      } else {
        continue;
      }

      if (!fs.existsSync(filePath)) continue;

      const content = fs.readFileSync(filePath, 'utf-8');
      const hasMastodon = hasMastodonField(content);

      if (!onlyMissing || !hasMastodon) {
        const slug = entry.isDirectory() ? entry.name : entry.name.replace('.md', '');
        files.push({ type, slug, filePath, hasMastodon });
      }
    }
  }

  return files;
}

// Main function
async function main() {
  console.log('\n🐘 Syncing Mastodon links to markdown files...\n');
  if (DRY_RUN) {
    console.log('🔍 DRY RUN MODE - No files will be modified\n');
  }
  if (FORCE) {
    console.log('🔄 FORCE MODE - Will overwrite existing mastodon fields\n');
  }

  // First, check which files need updating
  console.log('Scanning content files...');
  const filesToUpdate = findContentFiles(!FORCE);
  const label = FORCE ? 'files to check' : 'files missing mastodon field';
  console.log(`Found ${filesToUpdate.length} ${label}\n`);

  if (filesToUpdate.length === 0) {
    console.log('✨ All files already have mastodon field. Nothing to do!\n');
    return;
  }

  // Create a set for quick lookup
  const updateSet = new Set(filesToUpdate.map(f => `${f.type}/${f.slug}`));

  // Fetch account ID
  console.log(`Looking up account @${MASTODON_USERNAME}...`);
  const accountId = await fetchAccountId();
  console.log(`Found account ID: ${accountId}\n`);

  // Fetch all statuses
  console.log('Fetching all statuses...');
  const statuses = await fetchAllStatuses(accountId);
  console.log(`Found ${statuses.length} statuses\n`);

  // Build map of blog URLs to mastodon URLs (earliest status per slug)
  const matchMap = new Map(); // key: "type/slug", value: match object
  for (const status of statuses) {
    if (!status.content) continue;

    const links = extractLinksFromHtml(status.content);
    for (const link of links) {
      const parsed = parseDeepakNessUrl(link);
      if (parsed) {
        const key = `${parsed.type}/${parsed.slug}`;
        // Always overwrite to keep the earliest (last in reverse-chronological order)
        matchMap.set(key, {
          type: parsed.type,
          slug: parsed.slug,
          mastodonUrl: status.url,
          blogUrl: link,
        });
      }
    }
  }

  // Filter to only matches for files that need updating
  const matches = Array.from(matchMap.values()).filter(m => updateSet.has(`${m.type}/${m.slug}`));
  console.log(`Found ${matches.length} Mastodon posts for files needing update\n`);

  // Process matches
  let updated = 0;
  let skipped = 0;

  for (const match of matches) {
    const filePath = findMarkdownFile(match.type, match.slug);
    if (!filePath) continue;

    const relativePath = path.relative(ROOT_DIR, filePath);
    const content = fs.readFileSync(filePath, 'utf-8');

    // Check if file already has this exact mastodon URL (skip if same)
    const existingMatch = content.match(/^mastodon:\s*"([^"]+)"/m);
    if (existingMatch && existingMatch[1] === match.mastodonUrl) {
      console.log(`⏭️  Already correct: ${relativePath}`);
      skipped++;
      continue;
    }

    // Remove existing mastodon field if present (for --force)
    let newContent = content.replace(/^mastodon:\s*"[^"]+"\n/m, '');
    newContent = insertMastodonField(newContent, match.mastodonUrl);

    if (DRY_RUN) {
      console.log(`📝 Would update: ${relativePath}`);
      console.log(`   Mastodon URL: ${match.mastodonUrl}`);
    } else {
      fs.writeFileSync(filePath, newContent);
      console.log(`✅ Updated: ${relativePath}`);
    }
    updated++;
  }

  // Files that had no matching Mastodon post
  const notFound = filesToUpdate.length - updated - skipped;

  console.log(`\n✨ Done!`);
  console.log(`   Updated: ${updated}`);
  if (skipped > 0) {
    console.log(`   Already correct: ${skipped}`);
  }
  console.log(`   No Mastodon post found: ${notFound}\n`);
}

main().catch(error => {
  console.error('❌ Error:', error.message);
  process.exit(1);
});

The above Node.js script uses public Mastodon API endpoints that do not require authentication, so you don't even need an API key. It uses fs, path, url, and fetch libraries which are Node.js built-ins.

When I run the script in my terminal by running either npm run mastodon or node scripts/mastodon.js command in my terminal:

Scans my local markdown files in content/blog/ and content/raw/ folders, identifies which ones are missing a mastodon: field in their YAML frontmatter.
Fetches all posts from the @deepakness Mastodon account via the public API by paginating through all posts I have.
Matches posts to blog entries by scanning each Mastodon post's HTML content for links to deepakness.com/blog/[slug] or deepakness.com/raw/[slug], and then maps those back to the related local markdown files.
Updates the frontmatter of each matched markdown file by inserting a mastodon: "https://mastodon.social/..." field.

The script also has two optional flags:

--dry-run shows what would change without writing anything
--force overwrites existing mastodon: fields instead of skipping files that already have one

Also, when multiple Mastodon posts link to the same blog post, it keeps the earliest one (since posts are fetched in reverse-chronological order, the last match per slug is fetched).

Most probably, you won't be able to directly use this script as it's specific to how my 11ty blog is structured. But you can give the script to any LLM, provide info on how your static blog is structured, and ask to provide the modified version of the script.

I manually run the script every few days, so you won't see the "Comment on Mastodon" link on new posts right away – but it shows up soon enough.

Dynamic Open Graph Images for My 11ty Blog

2026-02-06T09:18:45Z

Apart from adding webmentions and better handling images, I also recently finished setting up dynamic Open Graph image generation on my 11ty blog, and it is now working for blog posts, raw notes, and standalone pages.

Earlier I was using just one default social image for all pages and posts I had. It worked, but all shared links looked repetitive. So I created a local generation script and connected it into my existing workflow.

In this post, I will show the exact setup I am using.

1. How OG image is selected on my website

I use computed data to decide what image goes into og:image and twitter:image and have this file _data/eleventyComputed.js with the following content:

export default {
  ogImage: (data) => {
    // If the post has a custom image in frontmatter, use that
    if (data.image) {
      return data.image;
    }

    // For blog posts and raw notes, use the co-located og.jpeg
    if (data.page && data.page.url) {
      if (data.page.url.startsWith('/blog/') || data.page.url.startsWith('/raw/')) {
        return `${data.page.url}og.jpeg`;
      }
    }

    // Fall back to default metadata image
    return null;
  }
};

And in my base template, _includes/layouts/base.njk, both Open Graph and Twitter tags read this value:

So the priority is:

image from frontmatter (manual custom image)
Generated co-located og.jpeg for /blog/* and /raw/*
Site default fallback image from metadata

And then the final Open Graph image URL looks something like how it looks in the above screenshot.

2. The generator script I use

I use sharp image library with a Node.js script at scripts/generate-og-images.js. And the script does the following:

Scans content/blog and content/raw
Scans top-level pages in content/
Handles homepage as a special case
Skips items that already have og.png, og.jpeg, or og.jpg
Skips items that already have image in frontmatter
Uses MD5 cache in .og-cache.json to skip unchanged items
Outputs 1200x630 JPEG images

It uses the Vercel's satori library for layout, @resvg/resvg-js for rendering SVG to PNG, and sharp to produce final JPEG. Here are some useful snippets from the generate-og-images.js script.

const CACHE_FILE = path.join(rootDir, '.og-cache.json');
const BLOG_DIR = path.join(rootDir, 'content', 'blog');
const RAW_DIR = path.join(rootDir, 'content', 'raw');
const PAGES_OG_DIR = path.join(rootDir, 'public', 'img', 'og');

if (item.hasExistingOg || item.hasCustomImage) {
  skipped++;
  continue;
}

if (cache[cacheKey] === item.contentHash && fs.existsSync(outputPath)) {
  cached++;
  continue;
}

const outputPath = item.collection === 'pages'
  ? path.join(PAGES_OG_DIR, `${item.slug}.jpeg`)
  : path.join(item.folderPath, 'og.jpeg');

It's a huge 600 lines of script, so I didn't paste it all here. But you can click this link to view the entire script.

3. Card design setup

I kept the design clean and consistent:

White background with a subtle grid pattern
Blue accent strip at the top
Large post title and optional description
Footer with profile photo, name, and website label

The fonts are loaded from local files, the same ones that I am using on my website, so final images match the aesthetics of the website. By the way, here's the OG image for this post, the one you're currently reading:

4. Commands and workflow

I just run the following command to generate images:

npm run og

In package.json, my local start flow already includes OG generation:

"start": "npm run optimize-images && npm run og && npx @11ty/eleventy --serve --quiet"

So in day-to-day writing, I can quickly regenerate social cards before publishing, and also optimize images on the go.

And above is the terminal output when I run the script.

5. Useful edge case: manual override

If I set an image in frontmatter, generator skips that post on purpose. That lets me keep dynamic generation as default, and still use a custom OG design for specific posts.

Example:

image: "/blog/vivaldi-browser/og.jpg"

That is the full setup I am using right now.

It keeps social cards consistent without manual design work on every post, and cache makes regeneration fast when nothing changes. I will keep improving the design over time, but this setup already works well for my workflow.

Adding Webmentions to My 11ty Blog

2026-02-03T12:10:53Z

I was thinking about this for a long but I finally added webmentions to my blog. I had zero knowledge about this from earlier, so I had to do a lot of reading about the webmention protocol to completely understand it. But I did... and it's live on my website. You can check out this post which has received some webmentions via Mastodon by the time of writing this post.

When you talk about webmentions, receiving and sending them are two different things. And it becomes little tricky to implement this on a static website like mine, which is built using 11ty static site generator.

In this post, I will explain my process of how I implemented both the receiving and sending of webmentions. Let's get to it.

1. Receive incoming webmentions

When other people link to your website from their blogs or interact with your blog posts on Mastodon or Fediverse, they send you webmentions that you need to receive to show on your website.

Using webmention.io service

To receive, I used webmention.io, created by Aaron Parecki, that automatically scans receiving webmentions and lets you access them via an API. When you sign up for it, it gives you a username, and you need to add below <link> tags to your HTML. It looks like this on my blog:

<link rel="webmention" href="https://webmention.io/deepakness.com/webmention">
<link rel="pingback" href="https://webmention.io/deepakness.com/xmlrpc">

And after you add this, the webmention.io service starts collecting webmentions on your behalf. You can pull these and show on your website via their API.

From here, you need to get the webmention.io API key token that we will need in the next step.

Showing webmentions on my blog

Each website is built differently so here I will only explain how I built the setup, and provide you with actual code snippets that I am using.

At first, I created a webmentions.js file in my _data folder with the following content:

import "dotenv/config";
import EleventyFetch from "@11ty/eleventy-fetch";

export default async function () {
  const domain = "deepakness.com";
  const token = process.env.WEBMENTION_IO_TOKEN;

  if (!token) {
    console.warn("WEBMENTION_IO_TOKEN is missing – returning empty webmentions.");
    return { children: [] };
  }

  const url =
    `https://webmention.io/api/mentions.jf2?domain=${domain}&token=${token}&per-page=1000`;

  // Always fetch fresh on each build
  const data = await EleventyFetch(url, {
    duration: "6h",
    type: "json",
  });

  return data;
};

I added the API key in the environment variable WEBMENTION_IO_TOKEN on Netlify, as it will be used during the build time.

Then I created a comments.njk file (here are entire contents of the file, including CSS) in the _includes folder, and used it inside my post template like below:

After this, I also used a service called Bridgy that connects some services that do not explicitly send webmentions, still grabs the webmentions from those platforms, and sends them to webmention.io. I added Bluesky to Bridgy and it will now grab comments and reactions from Bluesky as well, even though it doesn't natively support it.

And it was live. I could see some webmentions collected in my webmention.io dashboard and then those pages on my website were also showing them.

Above is an example of my current design for showing webmentions below posts and notes. I also created this /webmention page that educates people on what this is and how this works on my blog.

The webmention sections on my blog only updates when I publish something new and the site gets re-built on Netlify.

2. Send outgoing webmention notifications

I am using this amazing tool webmention.app, created by Remy Sharp, that automates your outgoing webmentions.

There are multiple ways to use the service, as explained in the docs. I am integrating the service with Netlify by using the "deploy notification" feature.

Open your project in Netlify
Go to Project configuration
Scroll down, click on Notifications
Scroll to Deploy notifications under Emails and webhooks section
Click on Add notification, select HTTP POST request option
In Event to listen for: select Deploy succeeded
Enter below URL in URL to notify field

https://webmention.app/check?token=[your-token]&limit=1&url=[your-feed-url]

Make sure to replace [your-token] with the Token that you get from webmention.app, and [your-feed-url] with the RSS/Atom feed of your website. By the way, there are ways to work without a feed URL as well, you need to go through the docs carefully.

Here are some useful resources that I found helpful during my setup:

Using Webmentions in Eleventy, by Max Böck
Webmentions for your Static Site by Rowan Manning
Sending webmentions from a static site by Sophie
Using Web Mentions in a static site (Hugo) by Paul Kinlan

I am new to this thing, and I am sure that the setup will evolve to become even better in the future. I will keep this page updated.

Starting a Newsletter using Listmonk

2026-02-01T16:57:53Z

I have been thinking about starting and maintaining a email list for a long time, and today I finally made it live. It wasn't a straightforward process but wasn't extremely complicated either, I had to Google a lot and was finally able to set everything up as I wanted.

For the setup, I used Listmonk (self-hosted) for managing the list and Amazon SES for sending the emails. I will try my best to explain the entire process.

But before I start, below is the form if you'd like to subscribe to my list. I have kept it simple to match the aesthetics of my website, and currently only showing the form in the footer.

Now, let's get to it.

What is Listmonk?

Listmonk is a self hosted email newsletter and mailing list tool. It lets you collect subscribers, manage lists, design emails, and send campaigns using your own email provider like Amazon SES, Mailgun, Sendgrid, and Postmark.

You control your data, your server, and how emails are sent, without paying per subscriber. It's great for newsletters, product updates, and simple email automation.

What is Amazon Simple Email Service (SES)?

Amazon SES (Simple Email Service) is a cloud email sending service from AWS. It is used to send emails at scale for things like newsletters, app notifications, and transactional emails.

You connect your app or tool like Listmonk to SES, and SES handles delivery, spam checks, and inbox reliability while charging based on how many emails you send.

Self-hosting Listmonk

I hosted Listmonk on a Hetzner VPS (CX23, costs $3.5/mo) via Dokploy and it took less than 5 minutes. Here are the steps:

Create an account on Hetzner, get verified, and create a new server. Even the cheapest server CX23 would be more than enough.
SSH into the server, and install Dokploy by following the instructions on their official website.
Open Dokploy, create a new project and create a new service by selecting the already available Listmonk option. Add a custom domain and then deploy the service.

If you see an outdated version of Listmonk in the Docker Compose file, change it to the latest version. In my case, it was v5.0.0 in the Docker Compose file, so I changed it to v6.0.0 which is the latest.

After the deployment is successful, visit the domain you added and register a new Listmonk account, and you should now be inside the app.

Getting the Amazon SES details

I didn't even have a AWS account so I was thinking it's going to be a complicated process, but it wasn't. I asked ChatGPT to guide me through the process and it did, I just kept providing it with screenshots.

Sign up or log in to the AWS account from here: https://aws.amazon.com/ses/
SES asks you to add and verify your email address and sending domain as well. For example, add and verify [email protected] and also your domain yoursite.com.
Keep other options in these sections as the default: Deliverability enhancements, Create your Dedicated IP pool, and Add tenant management. Review everything and click on Get started.
Verify your sending domain by adding a bunch of CNAME, DMARC, and SPF records at your domain registrar (or at Cloudflare if you're using it).
Now, create SMTP credentials and get the SMTP username, SMTP password, and AWS region (you'll need these inside Listmonk).

I will suggest using ChatGPT, Gemini, or any other AI provider to guide you through everything.

Setting up Listmonk

Now, let's get through the process of setting up Listmonk:

1. General settings

First, you need to do some basic settings in the Settings > General tab, as you see in the screenshot here.

Site name: Add the name of your website where you will be showing the subscription form.
Root URL: Add the root URL of where you have hosted Listmonk. Generally, people host at a subdomain of their main domain so the URL will be something like below
- https://list.yoursite.com
Logo URL: This is the logo that is shown at the top of your emails, you can upload the logo to the media library and add the URL here.
Favicon URL: This is shown as the favicon on the public archive pages, if you choose to make your issues public.
Default from Email: Add your email that you want to send from.
Admin notification emails: Add your email where you want to receive the notification when a campaign gets completed, and other admin related things.

2. SMTP settings

You now have do the SMTP settings and you will need your Amazon SES credentials that you created earlier. See the below screenshot for more info.

Enabled: Should be turned on.
Host: You need to add this, but replace the AWS_REGION here:
- email-smtp.AWS_REGION.amazonaws.com
Port: Use 587 as the SMTP server port.
Auth protocol: Use LOGIN.
Username: Paste the AWS SES username here.
Password: Paste the AWS SES password here.
HELO hostname: Leave it empty.
TLS: Selet STARTTLS here.
Name: Name anything you want.

And keep other options as the default. You can see above screenshot for more info.

You can test the setup by clicking on the Test Connection on the same screen. And if your SES account is not verified yet, you will only be able to send the email to yourself (the one you added in the AWS SES account).

3. Setting up the subscription form

Inside Listmonk, go to the Lists > All lists and rename the default list to the name of your newsletter. This will be seen by the users in the welcome email. You can select between single and double opt-in. I like to have double opt-in, because it's good for deliverability and also that only serious people get into your list.

Once the list is ready, navigate to Lists > Forms and you can either share the subscription form as the shown URL or get the HTML and embed it on your website.

I have embedded the HTML on my website and it looks like this:

<div class="newsletter-form">
  <p>One email every week on AI, tech, and marketing finds I'd tell a friend about.</p>
  <form method="post" action="https://listmonk.yoursite.com/subscription/form" class="listmonk-form">
    <input type="hidden" name="nonce" />
    <input type="hidden" name="l" value="9dcc7bc2" />
    <input type="email" name="email" required placeholder="Your email" />
    <input type="text" name="name" required placeholder="Your name" />
    <input type="submit" value="Subscribe" />
  </form>
  <p class="newsletter-note">No spam, just chaos.</p>
</div>

I have then added some CSS to make it look like how it currently looks in my website's footer. On mobile, form fields appear one above another.

4. Setting up a campaign template

I like sending plaintext emails so I had to create a new campaign template from Campaigns > Templates, but if you're fine with the default campaign template (you can see the preview), there's no need for this step.

Actually, it's not absolutely plaintext because I want to use the HTML's hyperlink feature.

As you can see, it's just basic HTML for adding hyperlink in Unsubscribe and View in browser links. I could use plaintext as well here, but the links look very ugly in the email.

5. Sending a test campaign

I recommend to subscribe to your own newsletter and then send a test campaign to make sure everything is working as expected. For sending a newsletter issue, go to Campaigns > All campaigns, delete the existing campaigns, and create a new one.

Name: Name it anything, it's internal and not shown to the subscribers.
Subject: The email subject that you want subscribers to receive.
Subject: From address that you added in Settings earlier and that you want to send the newsletter emails from.
Lists: Select the list or lists of subscribers whom you want to send the emails to.
Messenger: Keep as email.
Format: Select Rich text as the format.
Tags: Optional.
Send later: If you want to schedule, use Send later option and select date and time to send. Otherwise, keep it turned off.

Now, Save and go to the Content tab, select Rich text as the format, select either the default template or the new template you created previously, and start writing your newsletter.

As you see in the above screenshot, .Subscriber.Name between double curly braces will be replaced by the actual name of the subscriber. You can learn more about template expressions from this page in their docs.

After finishing writing, you can preview how it will look to the user, save changes, and start the campaign by clicking on the Start campaign button at the top.

And seconds later, I received this test email in my Gmail account. It plaintext, mostly, and just uses HTML for the hyperlinks and will probably use for images (if I add).

That's it.

If you're setting Listmonk for yourself and got stuck somewhere, please email me and I would be happy to help.

Update: Feb 4, 2026

Amazon has rejected my application for SES approval without giving any proper explanations, and I received this email from them.

Now, with SES out of the question, I evaluated other SMTP options and have settled with this service called SMTP2GO for now. It offers 1,000 emails per month for free (with a limit of 200/day), and that's enough for me as of now, as I do not any subscribers yet.

You can see my current Listmonk setup with SMTP2GO in the above screenshot. I tried subscribing to my newsletter from my other email, and it works well for now.

Trying and Migrating to Vivaldi Browser

2026-01-29T20:43:04Z

I have known the Vivaldi browser for years but never actually tried it, until it was recently recommended by Ralf Christian on X. Currently, I am using the Helium browser for the last few months, and it works fine but lacks some features like Widevine DRM, translation, etc.

So... this time I actually decided to try the Vivaldi browser. I'm on macOS currently, so I downloaded the .dmg installation file (~220 MB in filesize) and installed it as you would any other app.

In this post, I will share my experience of using the browser – things I liked and also things I didn't.

1. First impression

After opening the browser for the first time, the onboarding flow was great the import from other browsers worked fine as well. But when the actual window opened, it was overwhelming as there were a lot of panels, settings, etc.

It took me almost an hour to tweak small things and the final look was like this:

Here are the things that I liked and didn't like in the first hour of using the browser:

Loved the different themes it provides by default and how customizable is everything.
Settings window was overwhelming as it has lots of options, but it's like this for the good reasons.
Loved the widgets on the home page and used the Date and Privacy Statistics ones.
Break Mode (ctrl + .) is amazing.
Different profiles was an expected feature, but Workspaces are an added benefit.
The inbuilt screenshot and page tiling feature.
Proper support for Chrome extensions, I could easily install one from Chrome webstore.
Vertical tabs, I'm not using it but great to have the feature.
A built-in Pomodoro timer? Amazing.
Support for the Manifest v2 Chrome extensions. I successfully installed this Scraper extension.

2. Customizing as per my needs

I changed the below settings from how the browser ships with the default settings:

I don't like my tabs colors changing for different websites I visit, so I had to turn this off. But it was tricky, as searching "accent" in Settings doesn't show anything and I had to manually find this option under Themes > Editor > Accent from Page.
Removed the speed dials from new tabs, as I like to keep the new tab page clean. Currently, I'm just showing the Date and Privacy Statistics widgets on the Home.
Removed some items from the side panel, like some bookmarked websites, translation widget, some extensions that were shown, etc.
Turned off the Use Tab Zoom feature as it resets the zoom level when you re-open the website, and I wanted to retain the zoom level. I had to Google this one.

I must have changed one or two more settings, but overall this was it.

3. Things I loved

Some features in the Vivaldi browser are amazing and not available in most other browser I tried so far.

Secure sync feature

I love a reliable sync feature which is also secure, and Vivaldi has it. It provides an end-to-end encrypted sync feature that I connect multiple devices to and share tabs, bookmarks, settings, history, and so on.

I connected my personal browser profile to the Vivaldi browser on my Android phone, and the sync immediately start working.

Vivaldi for Android

Initially, I didn't know that Vivaldi even has a browser for Android phones as well, but I was amazed when I installed it. It didn't have as many customization options like the desktop one, but

I only spent like 5 mins customizing and it already looks great on my phone. And the best thing now is, I can easily share tabs between my laptop and my phone by using Send to Your Devices feature.

RSS feed reader

When you visit a blog and it has an RSS feed, you see a small feed icon in the right of the address bar and clicking on it opens a small dialog from where you can save the feed. And new posts will be automatically fetched on a regular interval for you to read.

It works much like a fully functional feed reader app. I currently use an RSS reader app called NetNewsWire, but it's great feature in the browser.

By the way, there's also the Reader View that helps you read any articles without distractions. This feature is available in most browsers though.

Page Actions

One more crazy feature that I haven't seen in any browser is the Page Actions that lets you tweak any webpage for your advantage. Some cool actions are:

Filter Black and White, Filter Grayscale, and even Filter Sepia
Fonts Monospace to convert the fonts on the webpage to monospace
Transition Removed to remove any kind of transitions

... and much more that you can learn about from their documentation.

Mail and Calendar clients

Vivaldi also has this stunning in-built email and calendar clients that you can connect your Gmail, iCloud, Outlook, or basically any account that supports IMAP or POP3.

I connected my Google Workspace account just to see how it works, but I won't be using this feature as I prefer directly checking my emails via the web interface. But it's a great feature for people who do prefer an email/calendar client.

Or... maybe I will use this feature after I get more comfortable with the browser.

4. Not so cool things

But like any other things in the world, nothing is perfect. I didn't like a few things in the browser:

Dragging a tab from my laptop screen to my second screen has some bugs. I tried dragging an already playing YouTube tab and then tab was lost – it's playing the background but not visible on either the first or second screen. I had to restart my browser to fix this issue.
Import feature doesn't work for different Chrome browser profiles. I tried importing my main profile and it worked, but I couldn't find a way to import other Chrome profiles. But it's not a deal-breaker, at least for me.

I have completely migrated to the Vivaldi browser and have set it up as my default browser on both my laptop and my phone. It's been only a few hours since I installed it, but I am loving it so far.

I will keep this page updated, if I learn something new about the browser.

Update: Jan 31, 2026

I turned off the drag-n-drop tab tiling feature by disabling the Enable Drag and Drop Tiling option under Settings > Tabs. It was buggy when I tried dragging away a tab into a new window or on my second screen (the same issue that I didn't like above).

It's working fine after turning this off, and I can still tile tabs by clicking on the Page Tiling option in the bottom panel.

Update: Feb 01, 2026

I modified the below options from the Settings:

Enabled Show Full Address from Settings > Address Bar > Address Field Options, as I like seeing the full URLs at the top.
Disabled Display Downloads Automatically from Settings > Downloads, as it was automatically opening the left side panel whenever I downloaded something.
Disabled Prioritize Bookmarks from Settings > Address Bar > Address Field Suggestions, as it was always over-prioritizing bookmarks even after opening another website with a similar name multiple times.

Update: Feb 03, 2026

The #1 bug I talked about in the above "not so cool things" section, has become really annoying, so I reported it to the Vivaldi team and hopefully they do something about it. I haven't received any response from them yet, but this is the bug I reported.

Currently, I am not dragging tabs out of the current window because this is super buggy. And since dragging windows work fine, I set up a keyboard shortcut cmd + ctrl + n to move tab to a new window. Now, I can immediately detach a tab from a window to a new window and then drag the new window to my second screen easily.

To set this up, go to Settings > Keyboard, expand Tab toggle, and press whatever combination you want in front of Move Tab to New Window option.

To be honest, I am liking the keyboard shortcut method much better than dragging the tab away.

Better Handling Images on My 11ty Blog

2026-01-27T17:57:12Z

Last year I migrated away from WordPress and now using 11ty SSG for my blog deepakness.com and while I was mostly happy with everything, I have also occasionally had second thoughts about using 11ty. And mainly because of the increasing Netlify build times as my blog grew, it was taking up to 1 min 23 seconds for a build. Once or twice I even hit my Netlify monthly 300 mins build time limits.

So I had to find a better way for the site, and I had the following two options in my mind:

Ditch 11ty and start using WordPress or something similar
Stay on 11ty and optimize the build time on Netlify

I went with the #2 option as it required much less work than migrating back to WordPress, and started looking into what's causing the build times to increase so much.

And it was the @11ty/eleventy-img plugin that I was using to dynamically optimize and transform images during build time. While it worked great, it wasted so much compute as it ran image transformations during each build. And I tried using netlify-plugin-cache for caching already transformed images, but it didn't properly work because I am co-locating all images in separate blog folders, as you see below:

blog/
└── some-post/
    ├── index.md
    ├── image-1.png
    └── image-2.png

So... what was the solution here?

I removed the @11ty/eleventy-img plugin and decided to locally process all images using the sharp image library, before sending them to Netlify because the build times will be faster then.

This worked as expected, and here's what I am doing with images:

Resize original images to 1600px, compress, and keep them in their original format
Create a .webp version of images (1200px wide), and save with the same filename
Track already optimized images in the .image-cache.json file via MD5 hash

And all this happens with the following script I created:

import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import sharp from 'sharp';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const ROOT_DIR = path.resolve(__dirname, '..');
const BLOG_DIR = path.join(ROOT_DIR, 'content', 'blog');
const CACHE_FILE = path.join(ROOT_DIR, '.image-cache.json');

// Configuration
const CONFIG = {
  webp: { maxWidth: 1200, quality: 80 },
  original: { maxWidth: 1600 },
  extensions: ['.jpg', '.jpeg', '.png'],
};

// Load or create cache
function loadCache() {
  try {
    return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
  } catch {
    return {};
  }
}

function saveCache(cache) {
  fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
}

// Calculate file hash
function getFileHash(filePath) {
  const content = fs.readFileSync(filePath);
  return crypto.createHash('md5').update(content).digest('hex');
}

// Find all images in blog folders
function findImages() {
  const images = [];
  
  if (!fs.existsSync(BLOG_DIR)) {
    console.log('Blog directory not found:', BLOG_DIR);
    return images;
  }

  const postDirs = fs.readdirSync(BLOG_DIR, { withFileTypes: true })
    .filter(d => d.isDirectory())
    .map(d => path.join(BLOG_DIR, d.name));

  for (const postDir of postDirs) {
    const files = fs.readdirSync(postDir);
    for (const file of files) {
      const ext = path.extname(file).toLowerCase();
      if (CONFIG.extensions.includes(ext) && !file.endsWith('.webp')) {
        images.push(path.join(postDir, file));
      }
    }
  }

  return images;
}

// Optimize a single image
async function optimizeImage(imagePath, cache) {
  const relativePath = path.relative(ROOT_DIR, imagePath);
  const hash = getFileHash(imagePath);
  
  // Skip if already optimized with same hash
  if (cache[relativePath]?.hash === hash) {
    console.log(`⏭️  Skipping (unchanged): ${relativePath}`);
    return false;
  }

  const dir = path.dirname(imagePath);
  const ext = path.extname(imagePath);
  const basename = path.basename(imagePath, ext);
  const webpPath = path.join(dir, `${basename}.webp`);

  try {
    const image = sharp(imagePath);
    const metadata = await image.metadata();

    // Create WebP version (max 1200px, quality 80)
    let webpPipeline = sharp(imagePath);
    let finalWidth = metadata.width;
    let finalHeight = metadata.height;

    if (metadata.width > CONFIG.webp.maxWidth) {
      const ratio = CONFIG.webp.maxWidth / metadata.width;
      finalWidth = CONFIG.webp.maxWidth;
      finalHeight = Math.round(metadata.height * ratio);
      webpPipeline = webpPipeline.resize(CONFIG.webp.maxWidth);
    }
    await webpPipeline
      .webp({ quality: CONFIG.webp.quality })
      .toFile(webpPath);

    // Optimize original (max 1600px, keep format)
    if (metadata.width > CONFIG.original.maxWidth) {
      const tempPath = imagePath + '.tmp';
      await sharp(imagePath)
        .resize(CONFIG.original.maxWidth)
        .toFile(tempPath);
      fs.renameSync(tempPath, imagePath);
      // Recalculate dimensions after resize
      const newMeta = await sharp(imagePath).metadata();
      finalWidth = newMeta.width;
      finalHeight = newMeta.height;
    }

    // Update cache with dimensions
    cache[relativePath] = {
      hash: getFileHash(imagePath), // Recalculate after optimization
      width: finalWidth,
      height: finalHeight,
      optimizedAt: new Date().toISOString(),
    };

    console.log(`✅ Optimized: ${relativePath} (${finalWidth}x${finalHeight})`);
    return true;
  } catch (error) {
    console.error(`❌ Error optimizing ${relativePath}:`, error.message);
    return false;
  }
}

// Main function
async function main() {
  console.log('\n🖼️  Starting image optimization...\n');
  
  const cache = loadCache();
  const images = findImages();
  
  console.log(`Found ${images.length} images to check\n`);

  let optimized = 0;
  let skipped = 0;

  for (const imagePath of images) {
    const wasOptimized = await optimizeImage(imagePath, cache);
    if (wasOptimized) optimized++;
    else skipped++;
  }

  saveCache(cache);

  console.log(`\n✨ Done! Optimized: ${optimized}, Skipped: ${skipped}\n`);
}

main().catch(console.error);

The script optimizes the original image, creates a WebP version of the image, and adds updates the .image-cache.json file to avoid re-optimization of the image(s). The script also adds the width and height of the images in the JSON cache file to be later used for width and height in the img tags to avoid any cumulative layout shift on the pages.

And after this my Netlify build time was reduced to just 20 seconds, as you see in the screenshot below:

And I use the HTML <picture> tag to show images as you see below.

<picture>
  <source srcset="./image.webp" type="image/webp">
  <img alt="alt text" decoding="async" width="1200" height="630" src="./image.png">
</picture>

The browser first tries to load the .webp version of the image, and if it's not supported then loads the optimized version in the original format (PNG/JPEG). I only link to the original image in my Markdown file as ![alt](./image.png) and the above picture tag with WebP is automatically added in the final HTML via the following code in the eleventy.config.js file:

	// Picture tag transform: wrap <img> with <picture> for WebP + fallback
eleventyConfig.addTransform("pictureTag", function(content, outputPath) {
  // Only apply to blog pages
  if (!outputPath || !outputPath.endsWith(".html") || !outputPath.includes("/blog/")) {
    return content;
  }

  // Load image dimensions cache
  let imageCache = {};
  try {
    const cacheContent = fs.readFileSync('.image-cache.json', 'utf-8');
    imageCache = JSON.parse(cacheContent);
  } catch {
    // Cache not found, continue without dimensions
  }

  // Extract blog slug from outputPath (e.g., "_site/blog/better-images/index.html" -> "better-images")
  const blogMatch = outputPath.match(/\/blog\/([^/]+)\//);
  const blogSlug = blogMatch ? blogMatch[1] : null;

  // Match <img> tags with jpg/jpeg/png src
  return content.replace(
    /<img\s+([^>]*?)src=["']([^"']+\.(jpg|jpeg|png))["']([^>]*)>/gi,
    (match, before, src, ext, after) => {
      // Skip if already inside a <picture> tag
      if (match.includes('data-no-picture')) {
        return match;
      }

      // Create WebP source path
      const webpSrc = src.replace(/\.(jpg|jpeg|png)$/i, '.webp');

      // Keep existing attributes, add decoding async if not present
      let attrs = before + after;
      if (!attrs.includes('decoding=')) {
        attrs += ' decoding="async"';
      }

      // Add width/height from cache if available
      // Convert relative src (e.g., "./image.png") to cache key (e.g., "content/blog/slug/image.png")
      if (blogSlug && !attrs.includes('width=')) {
        const imageName = src.replace(/^\.\//, ''); // Remove leading ./
        const cacheKey = `content/blog/${blogSlug}/${imageName}`;
        const cached = imageCache[cacheKey];
        if (cached?.width && cached?.height) {
          attrs += ` width="${cached.width}" height="${cached.height}"`;
        }
      }

    return `<picture>
      <source srcset="${webpSrc}" type="image/webp">
      <img ${attrs.trim()} src="${src}">
    </picture>`;
    }
  );
}

It's a bit complicated setup, but I am very much satisfied with the setup, and will stay with 11ty, for now.

Creating My First WordPress Plugin

2025-12-21T17:10:54Z

I created my very first WordPress plugin called Bulk Classic to Block, and now it's live on the WordPress.org repository. It was a fun process, but definitely wasn't straightforward as it took me almost a month to get the v1.0.0 live.

But I'm ready to explain the entire thing in detail in this blog post, so let's directly get to it.

1. The idea for the plugin

I had a really old WordPress website which was untouched for years and was still using the Classic Editor, and since there were 100s of pages on the site, it wasn't manually possible to convert each page to Blocks. So... I then got this idea of creating such a WordPress plugin which does this in bulk.

Initially, I didn't know if such a thing will even work or not, but I researched a bit and then started working on the plugin. I used Cursor AI and Google's Antigravity for developing this.

2. Initial submission to WordPress.org

I, first, submitted the plugin to WordPress.org on November 29, 2025 and received the following email immediately after that.

And then I heard nothing from them for a few days.

3. Plugin checked by a volunteer

13 days later, on December 8, 2025, I received the below email saying that a volunteer has checked my plugin and has identified some issues that need to be corrected and that I needed to resubmit the updated version.

Mainly, the issues were related to the following 2 things (along with the solutions suggested):

Use wp_enqueue commands
- wp_register_script() and wp_enqueue_script() to add JavaScript code from a file.
- wp_add_inline_script() to add inline JavaScript code to previous declared scripts.
- wp_register_style() and wp_enqueue_style() to add CSS from a file.
- wp_add_inline_style() to add inline CSS to previously declared CSS.
Nonces and User Permissions Needed for Security
- Please add a nonce check to your input calls ($_POST, $_GET, $REQUEST) to prevent unauthorized access.

4. Updated and re-submitted the plugin

I then updated the plugin as per the detailed suggestions from the volunteer and then re-submitted it for the approval on the same day. And also sent them this email as it was suggested in the previous email.

And then I waited and was expecting of some more issues flagged from the volunteer.

5. The plugin gets approved

To my surprise, today I received this email from WordPress saying that the plugin is now approved. I was happy that now it should be live, but then visiting this URL https://wordpress.org/plugins/bulk-classic-to-block/ showed nothing.

So... I went through the email again, this time reading every line, to discover that now I have to upload the approved code to WordPress Plugin Directory via SVN. This information was sent in another email that you see below.

I started learning about using SVN for WordPress and then got some understanding that it's version control system, much like Git. Also learned that it can be used via CLI as well as via some GUI clients like TortoiseSVN and SmartSVN, again, much like Git.

6. Uploading the plugin

I decided to use the CLI for using svn (Subversion) because what's even the fun in using this via the GUI. At first, I had to install this on my computer, and I am using macOS so decided to install svn via Homebrew by running the following command:

brew install subversion

The idea here was to pull the public WordPress.org repo of my plugin in a folder locally, copy the plugin files in the specified folders, and then push everything live. The code files (images) went in the trunk folder and then screenshots and icons went in the assets folder. Below are the svn commands I had to execute:

# Executed at first
svn checkout https://plugins.svn.wordpress.org/bulk-classic-to-block

cd bulk-classic-to-block

# After copying files to `trunk` and `assets` folders as specified above
svn status

svn add trunk/* assets/* --force

svn commit -m "Initial commit of plugin files"

svn copy trunk tags/1.0.0

svn commit -m "Tag version 1.0.0"

If you'd like, here's the entire text copied from my terminal.

deepak@m2air wordpress-org % svn checkout https://plugins.svn.wordpress.org/bulk-classic-to-block
A    bulk-classic-to-block/assets
A    bulk-classic-to-block/tags
A    bulk-classic-to-block/trunk
Checked out revision 3424796.
deepak@m2air wordpress-org % cd bulk-classic-to-block 
deepak@m2air bulk-classic-to-block % ls
assets	tags	trunk
deepak@m2air bulk-classic-to-block % svn status
?       assets/screenshot-1.png
?       assets/screenshot-2.png
?       assets/screenshot-3.png
?       trunk/LICENSE.txt
?       trunk/README.txt
?       trunk/bulk-classic-to-block.php
?       trunk/index.php
?       trunk/js
deepak@m2air bulk-classic-to-block % svn add trunk/* assets/* --force
A         trunk/bulk-classic-to-block.php
A         trunk/index.php
A         trunk/js
A         trunk/js/scripts.js
A         trunk/LICENSE.txt
A         trunk/README.txt
A  (bin)  assets/screenshot-1.png
A  (bin)  assets/screenshot-2.png
A  (bin)  assets/screenshot-3.png
deepak@m2air bulk-classic-to-block % svn status
A       assets/screenshot-1.png
A       assets/screenshot-2.png
A       assets/screenshot-3.png
A       trunk/LICENSE.txt
A       trunk/README.txt
A       trunk/bulk-classic-to-block.php
A       trunk/index.php
A       trunk/js
A       trunk/js/scripts.js
deepak@m2air bulk-classic-to-block % svn commit -m "Initial commit of plugin files"
Authentication realm: <https://plugins.svn.wordpress.org:443> Use your WordPress.org login
Password for 'deepak': ********************************************

Authentication realm: <https://plugins.svn.wordpress.org:443> Use your WordPress.org login
Username: deepakness
Password for 'deepakness': ********************************************

Adding  (bin)  assets/screenshot-1.png
Adding  (bin)  assets/screenshot-2.png
Adding  (bin)  assets/screenshot-3.png
Adding         trunk/LICENSE.txt
Adding         trunk/README.txt
Adding         trunk/bulk-classic-to-block.php
Adding         trunk/index.php
Adding         trunk/js
Adding         trunk/js/scripts.js
Transmitting file data ........done
Committing transaction...
Committed revision 3424811.
deepak@m2air bulk-classic-to-block % svn copy trunk tags/1.0.0
A         tags/1.0.0
deepak@m2air bulk-classic-to-block % svn commit -m "Tag version 1.0.0"
Adding         tags/1.0.0
Adding         tags/1.0.0/LICENSE.txt
Adding         tags/1.0.0/README.txt
Adding         tags/1.0.0/bulk-classic-to-block.php
Adding         tags/1.0.0/index.php
Adding         tags/1.0.0/js
Committing transaction...
Committed revision 3424816.
deepak@m2air bulk-classic-to-block %

And then my WordPress plugin Bulk Classic to Block was live, and I could access it from this URL: https://wordpress.org/plugins/bulk-classic-to-block/

7. Future updates

If I update anything to the plugin files in the future, I might need to run the following commands:

cd ~/bulk-classic-to-block

# copy or edit files
svn add assets/screenshot-4.png
# or edit readme.txt

svn commit -m "Update screenshots and readme"

Above is when I add a screenshot or a minor change without need to bump up the version, but when I have to do a new release then the process will be:

Make changes in files in the /trunk folder
Bump the version number in:
1. Main plugin file
2. readme.txt file
3. Changelog section
Commit /trunk by using the svn commit -m "message" command
Create a new tag (important) by running the following commands:

svn copy trunk tags/1.0.1
svn commit -m "Tag 1.0.1"

Also, some other helpful svn commands can be:

# See what changed
svn status

# See diff
svn diff

# Update local copy
svn update

That's it!

I wrote everything in detail here, because I would definitely need to look back at it in the future when I update the plugin or even when I have to publish a new plugin to WordPress.

Update: 22 Jan, 2026

I made the GitHub repository for the plugin open-source that you can access here. Now, you can either download the plugin from GitHub releases or directly install via the official WordPress.org repo.

Will keep adding plugin updates to this page in the future.

Upgrading Self-hosted Umami to v3 on a VPS

2025-11-19T17:24:51Z

I recently wrote about self-hosting Umami Analytics on a small Hetzner VPS using Docker and Caddy.

Since then, Umami shipped v3 and I wanted to upgrade my existing install (v2.19.0) without losing any data. In this post, I am sharing the exact steps I followed on my live server.

If you installed Umami by following my earlier post, this guide should be a direct drop-in upgrade for you.

1. Log in to the VPS

From my local machine (macOS), I first SSHed into the VPS:

ssh root@your_server_ip

The server is running Ubuntu 24.04 with Docker CE, same as before.

After logging in I noticed a pending kernel update and a restart notice, so I rebooted first to avoid surprises in the middle of the upgrade:

reboot

Then I connected again:

ssh root@your_server_ip

2. Confirm the current Umami setup

Once logged in, I checked what files are in the root directory:

ls

Output:

Caddyfile  docker-compose.yml

So I opened the docker-compose.yml to confirm the current setup:

cat docker-compose.yml

The important part looks like this:

This is the same Docker setup I used in the original installation post:

umami container using postgresql-latest image
db container running postgres:15-alpine
caddy in front, handling HTTPS and the domain

To make sure everything was running fine before touching anything, I checked the containers:

docker compose ps

Sample output:

NAME           IMAGE                                            COMMAND                  SERVICE   CREATED       STATUS                 PORTS
root-caddy-1   caddy:latest                                     "caddy run --config …"   caddy     4 weeks ago   Up 2 hours             0.0.0.0:80->80/tcp, ...
root-db-1      postgres:15-alpine                               "docker-entrypoint.s…"   db        4 weeks ago   Up 2 hours (healthy)   5432/tcp
root-umami-1   ghcr.io/umami-software/umami:postgresql-latest   "docker-entrypoint.s…"   umami     4 weeks ago   Up 2 hours (healthy)   3000/tcp

All good here.

3. Create a PostgreSQL backup (do not skip this)

Before changing any image or running migrations, I created a full dump of the Umami database.

Since the db service is using:

POSTGRES_DB=umami
POSTGRES_USER=umami

the backup command is:

docker compose exec db pg_dump -U umami umami > umami-backup-$(date +%F-%H%M).sql

This runs pg_dump inside the db container and saves the file on the host with a timestamp in the name.

Then I double checked that the backup file exists and has some size:

ls -lh umami-backup-*.sql

Output on my server:

-rw-r--r-- 1 root root 8.5M Nov 19 14:48 umami-backup-2025-11-19-1448.sql

8.5 MB looks right for my current traffic.

At this point, even if the migration failed, I can restore the DB using this SQL file. That gives a lot of peace of mind.

4. Update the Docker image to Umami v3.0.1

Next, I edited docker-compose.yml to point to the new v3 image.

I used nano:

nano docker-compose.yml

Inside the file, in the umami service, I changed this line:

image: ghcr.io/umami-software/umami:postgresql-latest

to this:

image: ghcr.io/umami-software/umami:3.0.1

Nothing else needed to change – the DATABASE_URL, DATABASE_TYPE, APP_SECRET, and the db service all stay the same.

After saving and closing nano (Ctrl+X, Y, Enter), I confirmed the change with:

grep -A3 'umami:' docker-compose.yml

Output:

  umami:
    image: ghcr.io/umami-software/umami:3.0.1
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami

Perfect.

5. Pull the new image

Now that the compose file points to 3.0.1, I pulled the new image:

docker compose pull umami

This downloads the ghcr.io/umami-software/umami:3.0.1 image. My output looked like this (trimmed):

[+] Pulling 18/18
 ✔ umami Pulled                                                                       16.0s 
   ✔ fc2cca81d0de Pull complete                                                        2.4s 
   ✔ ...
   ✔ 14e4cc53c863 Pull complete                                                       14.8s

Once this finished, the image was ready on the server.

6. Recreate the Umami container with v3

With the image pulled, I restarted just the umami service using the new image:

docker compose up -d --force-recreate umami

Output:

[+] Running 2/2
 ✔ Container root-db-1     Healthy                                                     0.8s 
 ✔ Container root-umami-1  Started                                                     1.1s

Note that the db container stays the same, including the data volume. We are only replacing the app container.

7. Watch the logs and wait for migrations

The first start after the image change will run database checks and migrations. To see what is happening in real time, I tailed the logs:

docker compose logs -f umami

The logs showed:

umami-1  | > [email protected] start-docker /app
umami-1  | > npm-run-all check-db update-tracker start-server
umami-1  | 
umami-1  | > [email protected] check-db /app
umami-1  | > node scripts/check-db.js
umami-1  | 
umami-1  | ✓ DATABASE_URL is defined.
umami-1  | ✓ Database connection successful.
umami-1  | ✓ Database version check successful.
umami-1  | Prisma schema loaded from prisma/schema.prisma
umami-1  | Datasource "db": PostgreSQL database "umami", schema "public" at "db:5432"
umami-1  | 
umami-1  | 14 migrations found in prisma/migrations
umami-1  | 
umami-1  | Applying migration `14_add_link_and_pixel`
umami-1  | 
umami-1  | The following migration(s) have been applied:
umami-1  |   └─ 14_add_link_and_pixel/
umami-1  |     └─ migration.sql
umami-1  |       
umami-1  | All migrations have been successfully applied.
umami-1  | 
umami-1  | ✓ Database is up to date.
umami-1  | 
umami-1  | > [email protected] start-server /app
umami-1  | > node server.js
umami-1  | 
umami-1  |    ▲ Next.js 15.5.3
umami-1  |    - Local:        http://localhost:3000
umami-1  |    - Network:      http://0.0.0.0:3000
umami-1  | 
umami-1  |  ✓ Starting...
umami-1  |  ✓ Ready in 485ms

This is exactly what you want to see:

DB connection successful
Migrations applied
Server starting and ready

Once I saw the app was ready, I pressed Ctrl + C to stop tailing the logs.

8. Confirm that Umami v3 is live

With the container running, I opened my Umami domain in the browser (the one I pointed to Caddy in the first post).

The login page loaded as usual. After logging in:

The dashboard still showed all the historical data
The list of websites was intact
New pageviews were being tracked without changing the tracking script

If something looked broken here, I still had my SQL backup file to fall back to, but in my case everything worked on the first try.

9. What to do if something breaks

If the logs show errors, or the app keeps restarting in a loop, here is a quick recovery plan:

Stop the stack:
```
docker compose down
```
Bring only the database back up:
```
docker compose up -d db
```

Restore the backup:

cat umami-backup-YYYY-MM-DD-HHMM.sql | docker compose exec -T db psql -U umami umami

Replace the file name with your backup file name.

Change the image back to the old one in docker-compose.yml:
```
image: ghcr.io/umami-software/umami:postgresql-latest
```
Start Umami again:
```
docker compose up -d umami
```

You should now be back on the old version with the old data.

10. Final notes

That is pretty much all I had to do to upgrade Umami from the postgresql-latest v2 image to 3.0.1:

One SSH session
One pg_dump backup
One image tag change
A pull, an up, and a quick log check

If you are running the same Docker + Caddy setup from my earlier post, you can follow the same steps line by line, just replace the IP and domain with yours.

If you try this upgrade and hit any issues, the logs and the SQL backup will be your best friends – check those first before touching anything else.

Self-hosting Umami Analytics on a VPS

2025-10-20T02:58:00Z

A few days ago, I self-hosted Plausible analytics and many people recommended that I should check Umami analytics as it's lightweight and updates are more frequent.

So here it is... I also self-hosted Umami analytics on a $3.50 Hetzner VPS to see if it actually lives up to the hype. First, I will explain the installation steps and then write about my experience.

Installing Umami on a Hetzner VPS

First, you need to have a Hetzner account where you can create new servers. If you do not have one, create one and then get yourself verified, if required (yes, I had to submit my ID a few years ago).

I also recorded a quick video showing everything from the start – from setting up the VPS to adding the website for tracking.

[email protected]/src/lite-yt-embed.min.css">

But if you prefer reading, keep going forward.

1. Set up the VPS

Create a new server, even the smallest shared server is enough to host Umami as people discussed that only 500 MB RAM is enough to efficiently run it.

Also, I'm not going to explain how to set up a new server on Hetzner so if you need help with that you can go through this post, as I have explained the process a bit.

And as explained, set up a Docker CE app instead of setting up a blank system as we'll be installing Umami via Docker.

Now, connect to the server via SSH from your terminal by running ssh root@your_ip_address command, and once connected, update the system by running the following command:

sudo apt update && sudo apt upgrade

And it's ready for the installation.

2. Umami and Caddy setup via Docker

While you can directly follow the official installing with Docker steps, I have a better way of doing it by also using Caddy for also setting up the custom domain.

For this, you need to create a docker-compose.yml file in the root by running the following nano command.

nano docker-compose.yml

Now, just copy-paste the below YML code in the file, then save and exit by pressing ctrl + x and then y. But replace replace-me-with-a-random-string with a string before pasting; I prefer running below openssl command:

openssl rand -base64 32

And then use the generated string below:

services:
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami
      DATABASE_TYPE: postgresql
      APP_SECRET: to4KhI0g8Wzaw1r7+vEknSbU4AM4d6LRJyGzlgO5DZY=
    depends_on:
      db:
        condition: service_healthy
    init: true
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
      interval: 5s
      timeout: 5s
      retries: 5

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami
    volumes:
      - umami-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5

  caddy:
    image: caddy:latest
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    depends_on:
      umami:
        condition: service_started
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config

volumes:
  umami-db-data:
  caddy_data:
  caddy_config:

Now, create a Caddyfile by running the below command and paste the below Caddyfile code, but first replace the your_domain_or_subdomain_here with your domain/subdomain.

nano Caddyfile

For example, I can connect it to umami.deepakness.com. Again, press ctrl + x and then y to save and exit.

your_domain_or_subdomain_here {
  encode zstd gzip

  reverse_proxy {
    to umami:3000
    health_uri /api/heartbeat
    health_interval 10s
    health_timeout 2s
  }

  log {
    output stdout
    format json
  }
}

Also, you will need to add a DNS record at Cloudflare (if you're using) or at your domain registrar. You need to add an A record with your IP address.

For example, I use Cloudflare and this is how I'd add the A DNS record in there.

3. Start Docker containers

Now, everything is ready, and you can just start the docker container by running the below command. It starts all the containers in the background.

docker compose up -d

And then you can also run the below command (optional) to see live logs from the Caddy container so you can see if it gets the SSL certificate and starts properly.

docker compose logs -f caddy

And your Umami Analytics instance should be live!

You can visit the domain/subdomain and should see the login screen, and your default username will be admin and password umami. But you should immediately change your password after logging in.

And that's it.

You can add your website(s) for tracking and start collecting data as explained in their docs.

My experience with Umami

Actually, I liked Umami a lot, it's better than Plausible in terms of server resource usage. You can see the usage here for both:

Plausible is using 1 GB of RAM:

Umami is using ~500 MB of RAM:

Apart from this, I also liked the Umami dashboard a lot as it shows more tracking data while consuming 50% less resources than Plausible. Also, Plausible keeps showing a huge footer like below on all pages which I didn't like, but it's not there in Umami.

Apart from this, I liked the data points being shown in Umami, especially the way sessions and events data is shown.

So... that's it.

This time, I am going with Umami as it seemed more polished to me.

Update: November 19, 2025

I upgraded Umami to v3.0.1 and it was a smooth process. Check out my post on upgrading Umami to v3 for more details. I have explained the process in detail.

Self-hosting Plausible on a Hetzner VPS

2025-10-18T13:19:01Z

Previously, I have always used Google Analytics to track visitors on my website, but this time, I decided to use Plausible analytics on my personal website. And mainly because of the following three reasons:

Plausible is lightweight so doesn't affect the website loading speed much
Unlike Google Analytics, Plausible is open-source and privacy-friendly, and
The Plausible dashboard is user-friendly and shows essential data without complexity

Now, let's directly go to the self-hosting part. I will explain each and every step of self-hosting Plausible CE on a Hetzner VPS.

1. Set up a Hetzner VPS

If you don't have a Hetzner account, create one and get yourself verified by submitting an ID proof (I don't know if that's for everyone, but did have to submit). After logging in, go to console.hetzner.com page, create a Project and then go inside the Project to create a Server.

Click on the big Add Server button, and you will land on the below page. In this case, select the Cost-Optimized x86 (Intel®/AMD) version and then the CX23 server as shown in the screenshot. And this is more than enough to run Plausible, as it only requires 2GB of RAM to run efficiently, and we have 4GB here.

Below are the recommendations for other options on the page:

Location: Leave the location to Helsinki as cheaper servers are available here.
Image: Instead of choosing OS Images, go to the Apps section and choose Docker CE.
Networking: Make sure IPv4 and IPv6 are selected, they should already be selected.
SSH Keys: If you use SSH keys on your computer, I'd recommend using these for easier access later. Maybe look it up online on how to set it up for your OS.
Leave Volumes, Firewalls, Backups, Placement Groups, Labels, and Cloud config as they are. No need to write anything here.
Name: Give your server a recognizable name for future references. You can always change it later.

Click on the Create and Buy Now button and your server will be ready in a few minutes.

2. Install Plausible on the server

Now, you will have to connect to the server from your local Terminal and then install the Plausible CE on the server. To connect, you need to copy the IPv4 from the server that just got created, and run the following command from your terminal:

ssh root@YOUR_IPv4_ADDRESS

If you have the server connected via SSH, you just have press Enter again, and it will be connected. Otherwise, you might need to enter the server root password.

If you don't choose the SSH method, you will receive the root password via email.

After your terminal gets connect to the server, you can update the server by running the following command:

sudo apt update && sudo apt upgrade

It should look like below:

After this completes, go to the Plausible community edition GitHub repo and follow the instructions. First, you need to run the following command to clone the repo (but make sure to check the latest command from the repo):

git clone -b v3.0.1 --single-branch https://github.com/plausible/community-edition plausible-ce

Now, go the plausible-ce folder by running below command:

cd plausible-ce

Create a .env file by running the following command:

touch .env

And then add BASE_URL and SECRET_KEY_BASE by running the following commands:

echo "BASE_URL=https://plausible.example.com" >> .env

echo "SECRET_KEY_BASE=$(openssl rand -base64 48)" >> .env

Make sure to replace BASE_URL with the URL where you want to host Plausible. You will also need to add an A DNS record with your server IP at Cloudflare (if you're using) or at your domain registrar.

You can also manually add BASE_URL and SECRET_KEY_BASE by running the nano .env command in the terminal.

Now, run the below commands one by one:

echo "HTTP_PORT=80" >> .env

echo "HTTPS_PORT=443" >> .env

And the run the following command:

cat > compose.override.yml << EOF
services:
  plausible:
    ports:
      - 80:80
      - 443:443
EOF

Finally, it's time to start the services with Docker Compose by running the below command:

docker compose up -d

And you will see something like below in the terminal:

Now, it's time to create user and add your website for tracking.

I have created a short video for self-hosting Umami, so some steps will be the same when installing Plausible.

3. Start tracking visitors

First, you will need to create a user by visiting the BASE_URL you set earlier, something like https://plausible.example.com and create an account with your credentials.

And when asked, add the domain you want to track, something like deepakness.com, and go to the next step. You can enable optional measurements as shown below, and then Copy the script that's being shown in the box.

Now, go to your website and add the script somewhere between the <head>...</head> tags on your website, as explained in their docs. If you're having difficulties, you can also check this page for different installation options for websites with different tech-stacks.

Lastly, click on the Start collecting data button, and you should be good to go within a few minutes. Once correctly installed, you'll start seeing the data being shown in the dashboard.

And the best thing is, you can track users on multiple websites from the single Plausible dashboard.

While I have provided all the commands here in the post, I recommend checking on the Plausible community edition repo in case something changes.

That's it.

I also self-hosted Umami analytics as it was recommended by a lot of folks. In the post, you can also see a short comparison between the both.

Hope this helps.

Trying and Migrating to the Helium Browser

2025-10-03T02:08:51Z

I was using the Brave browser for a few years now, but was also trying different browsers like Ungoogled Chromium and LibreWolf in the search of something better. Honestly, I didn't know what I was looking for in my web browser, but I just kept trying them.

However, I kept coming back to the Brave browser as it has everything that others lack.

But this time, I have completely migrated to the Helium browser, and for the good only. The browser was recommended to me by Fardeen on X, and I installed it the next day after I saw multiple people mentioning online.

It's been over a week since I'm using the open-source Helium as my default browser now, and I've never been happier using a web browser. In this post, I will be sharing my experience – the good, bad, and everything.

1. Clean and quick

When I first installed, I didn't see any annoying bloatware at all. It looked very clean and minimal on the very first install, and it didn't even have the background image set on new tabs. Unlike the Brave browser, it doesn't have:

sponsored backgrounds
crypto bloats
unnecessary AI push

Below, take a look at how clean it looks.

And the migration process was quicker than I thought, as I was able to import my Brave browser profiles within seconds – from history to bookmarks and even the extensions I could import everything.

2. Based on Chromium

To be honest, I've always liked Chromium engine more than that of any other browser, and the Helium browser is based on Chromium project itself. It's fast and supports all Chrome browser extensions as well.

In fact, it also supports the Manifest v2 extensions and comes with uBlock Origin preinstalled. And manifest v2 is a big deal for me because I want extensions like uBlock Origin, Scraper, and more correctly working for me.

3. Safe and secure

The Helium browser comes with all the good features of the Brave browser in terms of security and also without the tracking capabilities of the Google Chrome browser.

I also noticed that it doesn't save your addresses, card details, passwords, etc. as these features are completely removed from the browser. And I like this a lot because on Brave or Chrome, I always first turned off these features when getting started.

But it still does have the "Use secure DNS" feature which I absolutely need, as I use the Cloudflare's 1.1.1.1 DNS resolver.

4. Cool features

While I don't use extra features a lot, but they're good to have, and I like them so far. For example:

!bangs are awesome
Split View is handy sometimes

I also like that it lets me completely customize the top toolbar. By the way, this option appears when you right-click anywhere on the toolbar.

There's one minor inconvenience of using the browser is that it can't play DRM protected content in the browser, means, you won't be able to watch Netflix or Amazon Prime in the browser. And it makes sense because Helium doesn't have Widevine DRM, as it costs tens of thousands of dollars to get. But it's not a deal-breaker for me, as I rarely watch DRM content on my computer and even if I sometimes do, I still have Brave installed that I can use.

Apart from this, I'm absolutely loving the browser and sticking with it.

Also, it'd be great if the browser was available for mobile devices as well, but I don't think that's possible as of now.

Update: Oct 8, 2025

I just noticed that the Helium browser also doesn't have the translation feature as if you're visiting a page that's not in the language you know, you can't translate. But that's not a big deal for me, I can use some browser extension for that when needed.

Update: Nov 5, 2025

Now, it's been more than a month, and I'm still sticking with the Helium browser. I love how clean it is and how there are no distracting elements in the browser. The browser has received 1-2 updates since the installation, but I didn't notice any major changes – everything works as expected.

The browser is very stable and definitely consumes less RAM and resources than the Chrome and even the Brave browser. In the past one month, I had to open the Brave browser for one-time to translate a webpage (as Helium doesn't support translation), otherwise it's good so far.

Update: Jan 30, 2026

I loved the Helium browser as it was my default browser for almost 4 months, but I have recently migrated to the Vivaldi browser.

macOS App to Show Lid Angle in the Menu Bar

2025-09-11T08:51:46Z

I came across this cool project where Sam was able to access a hidden API from macOS which output the current angle of the lid. He built a cool app that accessed the API and showed the angle, as shown in the video here.

I was inspired by the project a lot and decided to build my first macOS app – an app that just shows the current tilt angle of the lid/screen in the menu bar. Here's a quick demo video showing the same.

[email protected]/src/lite-yt-embed.min.css">

I also posted about the same on X along with the public GitHub repo that you can clone and run the app via XCode on your MacBook devices.

To build this, I set up a macOS app project in XCode and then used OpenAI Codex to build the app for me. It took several iterations and also some manual researching and reading about the hidden LidAngleSensor API and how it can be accessed. And then it finally worked.

I still don't know how to get the final executable file from here, but I am reading about it and should also release the .dmg file that one can use to directly install this with just a click.

I have added some more info about how this works and limitations in the README.md file on GitHub. You can learn some interesting things about the API and the app from there.

Will keep updating the post as I discover more.

Git and GitHub for Vibe Coders

2025-09-09T18:09:56Z

This post is written using AI (unlike my other posts). Sometimes, I revisit some of these git commands and it was meant to be a private note, but then I published it because others might also find this useful.

I've been coding with AI tools like Cursor, Claude Code, and OpenAI Codex for a while now, and let me tell you – it's both amazing and terrifying. One moment you're asking AI to "add user authentication to this app," and the next moment you're staring at 200 lines of generated code wondering if it just broke your entire project.

And this is called vibe coding (coined by Andrej Karpathy) – using AI to generate code based on prompts and vibes rather than writing every line yourself. It's incredibly powerful, but it can also turn your codebase into chaos if you're not careful.

That's where Git and GitHub come in. Think of them as your safety net when AI coding goes sideways.

Why vibe coders desperately need Git

Here's the thing about vibe coding: you often don't fully understand what the AI just generated. Sure, it looks right, and it might even work, but what happens when you realize it broke something else? Or when you want to undo that "small refactor" that turned into a complete rewrite?

Without Git, you're basically coding without a parachute.

Git is essentially a time machine for your code. Every commit is a snapshot you can return to, and every branch is a parallel universe where you can experiment without consequences.

Git vs GitHub

I used to think Git and GitHub were the same thing. Spoiler alert: they're not.

Git is the actual version control system that runs on your computer. It works completely offline and tracks all your changes locally. You can use Git without ever touching the internet.
GitHub is a website that hosts your Git repositories online. It's like Google Drive for your code repositories, but with extra features like Issues, Pull Requests, and Actions.

Think of it this way: Git is like having a really good filing system for your documents, and GitHub is like having that filing system backed up to the cloud where others can collaborate with you.

Installing Git (first things first)

Before we can configure Git, we need to make sure it's actually installed on your system. Let's check if you already have it:

git --version

If you see something like git version 2.39.0, you're good to go! If you get a "command not found" error, you need to install Git.

On macOS

The easiest way is using Homebrew (if you have it):

brew install git

Or download the installer from git-scm.com. macOS also comes with an older version of Git that gets installed when you run git for the first time, but I recommend getting the latest version.

On Windows

Download the installer from git-scm.com. It comes with Git Bash, which gives you a Unix-like terminal that's perfect for running Git commands.

On Linux

Most Linux distributions include Git in their package managers:

Ubuntu/Debian:

sudo apt update
sudo apt install git

CentOS/RHEL/Fedora:

sudo yum install git
# or on newer versions:
sudo dnf install git

Once installed, run git --version again to confirm it's working.

Setting up Git (the boring but necessary part)

Before you start, you need to tell Git who you are. Run these commands once:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

That's it. Now Git will stamp your name on every commit you make. You only need to do this once per computer.

The basic Git workflow that changed my coding life

Here's the workflow I use every single day:

1. Check what's changed

git status

This shows you which files have been modified, added, or deleted. I probably run this command 50 times a day. It's like asking Git "what's different since my last commit?"

2. Stage your changes

git add .

This tells Git "I want to include all these changes in my next commit." You can also add specific files with git add filename.js if you want to be more selective.

3. Commit your changes

git commit -m "Add user authentication system"

This creates a permanent snapshot of your staged changes. Write a clear message describing what you did. Future you will thank you for this.

4. Push to GitHub

Before you can push, you need to connect your local repository to a GitHub repository. Here's how:

First time setup:

Create a new repository on GitHub (go to github.com, click the "+" icon, select "New repository")
Copy the repository URL (it looks like https://github.com/yourusername/your-repo-name.git)
Connect your local repo to GitHub:

git remote add origin https://github.com/yourusername/your-repo-name.git
git branch -M main
git push -u origin main

After the first setup:

git push

The first command (git remote add origin) tells Git where your GitHub repository is located. The second command (git branch -M main) ensures your main branch is named "main" (GitHub's default). The third command (git push -u origin main) pushes your code and sets up tracking so future pushes just need git push.

This uploads your commits to GitHub, backing up your work and making it available to collaborators.

I do this cycle constantly – sometimes every 10-15 minutes when I'm actively coding with AI assistance. Each commit is a checkpoint I can return to if things go wrong.

Creating a repository (your project's home)

To start tracking a new project:

git init

This creates a hidden .git folder in your current directory and starts tracking changes.

If you want to work on an existing project from GitHub:

git clone https://github.com/username/repository-name.git

This downloads the entire project and its history to your computer. For example, look how I am cloning a GitHub repo called optisharp to my computer.

Branches: Your experimentation playground

Branches are where Git really shines for vibe coders. Think of them as parallel timelines where you can try things without affecting your main code.

Create a new branch:

git checkout -b experiment/new-feature

Now you can ask AI to implement that crazy idea you had. If it works great, you can merge it back. If it breaks everything, just switch back to your main branch:

git checkout main

And delete the failed experiment:

git branch -d experiment/new-feature

I use branches for literally everything:

fix/header-bug for bug fixes
feature/payment-integration for new features
experiment/ai-suggestions for testing AI-generated code

The .gitignore file (don't commit everything)

Some files shouldn't be tracked by Git. Create a .gitignore file in your project root:

node_modules/
.env
*.log
dist/
.DS_Store

This tells Git to ignore:

node_modules/ (huge folder of dependencies)
.env (contains secret keys)
*.log (log files)
dist/ (build output)
.DS_Store (macOS system files)

Never commit secrets, large binary files, or generated content. Your repository should only contain source code and configuration files.

My vibe coding safety rules

After months of AI-assisted coding, here are the habits that have saved me countless times:

Commit before asking AI to change anything major

Before telling Claude "refactor this entire component," commit your current working state. This gives you an instant undo button.

Use descriptive commit messages

Instead of "updates" or "fixes," write:

"Add user registration form with validation"
"Fix mobile navigation menu bug"
"Refactor database connection logic"

Review AI changes before committing

Use git diff to see exactly what changed:

git diff

This shows you line-by-line what the AI added, removed, or modified. Sometimes AI changes more than you expected.

Push frequently

Don't let a day go by without pushing to GitHub. Your laptop could die, you could spill coffee on it, or you might accidentally run rm -rf in the wrong directory (yes, I've done this).

GitHub: Your cloud backup and collaboration hub

GitHub adds powerful features on top of Git:

Issues: Track bugs and feature requests Pull Requests: Review code changes before merging
Actions: Automate testing and deployment Releases: Tag stable versions of your code

Even as a solo vibe coder, I use GitHub Issues to track what I want to build next. It's like having a todo list that's tied to your codebase.

When things go wrong (and they will)

Undoing your last commit

git reset --soft HEAD~1

This undoes your last commit but keeps the changes in your working directory. Useful when you commit too early or have a typo in your commit message.

Going back to a previous commit

git log --oneline

This shows your commit history. Find the commit you want to return to and:

git checkout abc1234

(Replace abc1234 with the actual commit hash)

Dealing with merge conflicts

Sometimes Git can't automatically merge changes. When this happens, Git will mark the conflicting sections in your files:

<<<<<<< HEAD
Your current code
=======
The conflicting code
>>>>>>> branch-name

Edit the file to keep what you want, remove the conflict markers, then commit the resolved version.

My current vibe coding setup

Here's how I actually use Git and GitHub in my day-to-day AI-assisted coding:

Start with a branch for each new feature or experiment
Commit every 15-20 minutes when actively coding
Push at least once per coding session for backup
Use clear commit messages that explain the "why," not just the "what"
Review AI changes with git diff before committing
Create Pull Requests even for solo projects to review my own work

This might seem like overkill, but it's saved me so many times when AI-generated code broke something unexpectedly.

The honest truth about learning Git

Git has a learning curve. Commands like rebase, cherry-pick, and bisect can seem intimidating at first. But here's the thing: you don't need to master everything on day one.

Start with the basics I've covered here:

git add
git commit
git push
git status
git checkout (for branches)

These five commands will handle 90% of your needs as a vibe coder. You can learn the advanced stuff when you actually need it.

The key is to start using Git now, even if you don't understand everything. It's better to have imperfect version control than no version control at all.

Why this matters for vibe coders specifically

Traditional programmers write code line by line, understanding every character. They might go hours between commits because they're building something incrementally.

Vibe coders work differently. We prompt AI, get large chunks of generated code, test it, and iterate. This creates unique challenges:

Large, sudden changes that might break existing functionality
Code we don't fully understand initially
Rapid experimentation with different approaches
Need to roll back entire features quickly

Git is perfectly suited for this workflow. Every commit is a checkpoint, every branch is an experiment, and every push is a backup of your progress.

Getting started today

If you're not using Git yet, here's what to do right now:

Install Git from git-scm.com
Create a GitHub account at github.com
Run the config commands to set your name and email
Go to your current project and run git init
Create a .gitignore file for your project type
Add and commit your existing code
Create a repository on GitHub and push your code

Don't wait until you "understand Git better." Start with the basics and learn as you go.

Final thoughts

Git and GitHub aren't just tools for professional developers – they're essential safety equipment for anyone doing vibe coding. The ability to experiment fearlessly, knowing you can always undo changes, is liberating.

I've seen too many people lose hours of work because they didn't have version control. Don't be one of them. Start using Git today, commit frequently, and let AI help you build amazing things without the fear of breaking everything.

Your future self will thank you when you can confidently tell Claude Code or Cursor to "refactor this entire codebase" knowing you can always go back to the last working version.

Happy vibe coding!

How to Run Omarchy on a MacBook via UTM

2025-09-02T16:20:24Z

During my college days, I used Manjaro Linux for 4-5 years and I loved it. And I am feeling the same excitement again after learning about DHH's new Arch-based Omarchy Linux distro.

Currently, I use a MacBook M2 Air and do not have another machine to install and use the distro, but I wanted to give it a try. So I tried running Omarchy via UTM (VM for macOS) on my machine, and I finally got it working after almost an hour of trying different settings in UTM. And here's how it looked:

But please note that I wasn't able to actually work on it, as it was considerably slow and laggy. So... install it only if you just want to play with it.

Here's how I got it working...

1. Download Omarchy ISO and install UTM

The very first step is to download the Omarchy ISO from their official website, and save somewhere on your computer. It was around 1.5 GB in size when I tried, but might change a bit in the future.

Then you have to install UTM by downloading the .dmg from their official website, and installing them by double-clicking on the file, just like how you install any other macOS app.

2. Set up a new virtual machine

Open the UTM app and set up a new virtual machine by clicking on the Create a New Virtual Machine button, and below are the options you have to change – leave options, which I haven't mentioned here, as default.

Select Emulate option, as we have to run another CPU architecture
Select Linux option
Click on the Browse button and select the Omarchy ISO file, and click Continue
Select x86_64 in the Architecture dropdown, leave System as the default
Make the Memory to be 8 GB i.e. 8192 MiB, and click Continue
Either leave the size to be 64 GiB or can also make it 32 GiB, click Continue
Optional, but you can select a shared directory path, click Continue
Give your VM a name and Save
Right-click on the VM in UTM sidebar, and select Edit option
Go to the Display section
Select virtio-gpu-pci in the Emulated Display Card dropdown (see screenshot below)
Check the Retina Mode option and Save

Below I am adding some screenshots, in case that's helpful for you during the process.

Let's move to the next and last step now.

3. Start the installation process

Click on the big Play button (see above screenshot), and it will start the installation process. It will ask you some details during the installation process which you can learn more about in the Omarchy documentation.

Now it will take time... a lot of time, actually.

In my case, it took me more than 30 minutes. You have to just let it work in the background and do nothing, maybe grab a cup of coffee or can even take a quick walk outside.

After the installation, it automatically restarts and might again ask you for the details that you just provided during the installation.

But do not move forward.

Instead, shut down the VM, right-click on the VM in the sidebar and select the Edit option. Go to the first IDE option shown in the sidebar below, and click on the Clear button beside Browse to remove the selected Omarchy ISO (see below screenshot for more clarity).

Now Save, and restart the VM by clicking on the Play button. You should be asked to enter your password and see your beautiful Omarchy desktop.

And you're done!

As I have mentioned in the start, this will not be very performant, but you can definitely get the glimpse of Omarchy.

Are Double Quotes Replacing Single Quotes?

2025-07-20T01:16:59Z

Recently, I was editing a document and noticed that I instinctively used double quotation marks (" ") instead of single ones (' '). It made me pause for a second – didn't I grow up using single quotes for things like speech and dialogue?

That led me down a rabbit hole of how quotation mark usage has been changing. And yeah, things have shifted a bit – but it's not as straightforward as "double quotes are taking over single quotes."

It depends on where you're from

In the US, double quotes have always been the default. In the UK, it's traditionally been single quotes. But this line is starting to blur. Some big UK newspapers (like The Telegraph and The Times) now follow what's more common in the US. Even the term "quotation marks" is becoming more common than the older "inverted commas" in Britain.

Fun fact: double quotes were actually more popular in the UK before the 1950s. Single quotes came in later, mainly because they took up less space in print.

But look at this today's article in the Telegraph UK, they haven't used any single quote in the whole of the article, but only double quotes. In fact, none of their articles have single quotes anymore.

But... publishing still has its own rules

Publishing houses and editors haven't all switched to one style. The AP Stylebook still prefers double quotes in the US. Meanwhile, British publishers stick to their traditional style – unless the audience is more international. In that case, they might lean American.

Also, with things going more digital, there's pressure to make everything consistent. For example, many digital platforms don't even treat curly quotes properly in search – which is wild if you care about accuracy in research.

Then there's texting, typing, and social media

This is where things get messy. Most of Gen Z don't bother with proper punctuation when texting. And I totally get it – it's just faster. Pulling up smart quotes on a mobile keyboard is annoying.

On social media, people have created their own ways to show quotes. Sometimes they don't even use punctuation. They just use formatting, screenshots, or emojis to make a point.

So if you're typing on your phone, you're probably using straight quotes, or skipping them altogether. I do it too, especially in casual messages or tweets.

Style guides are slowly adapting

Style guides from places like Notre Dame and newer journalist groups have started updating their rules. They know people aren't typing the same way they did 10 years ago. So while they still prefer double quotes in formal writing, they're acknowledging that habits are changing – especially online.

The real picture

If you're wondering whether single quotes are disappearing, the answer is: yes, somewhat.

But they're also being used differently depending on the context, and both single and double quotes are still around. It's just that we're now using them based on what feels right for the situation – and honestly, that makes sense.

Calling Myself an Internet Generalist

2025-06-09T16:44:04Z

Starting today, I'm calling myself an internet generalist – because it describes me well.

If you're wondering what that means:

An internet generalist is someone with a broad range of skills and knowledge related to working online. They might be familiar with things like:

Programming
Writing and editing
Online marketing
Graphics design
Leveraging AI, etc.

Basically, they’re good at handling many kinds of online tasks and are especially useful in small teams or startups, where people often need to wear multiple hats.

Trying the Sarvam-M 24B Indic LLM

2025-05-27T03:41:59Z

Sarvam AI has released its very first Hybrid Indic LLM called Sarvam-M 24b built on top of the Mistral-Small model (hence the M in the name). It's a text-only model trained on all major Indian languages. You can run it locally on your computer as it's open-source, use on the playground, and also available via API.

I came to know about the launch from X and there are mixed opinions about the launch. But I am going to try it anyway and document my learnings in the post.

The first impression

I skimmed through the launch blog post to see the benchmark and the numbers are impressive when compared against Mistral Small 24B, Gemma 3 27B, Llama 4 Scout 17B/109B, and Llama 3.3 70B. It's claimed to perform:

20% better on Indian language tasks
21.6% better on math tasks
17.6% better on programming tasks

The model is trained to understand and generate text in 10 Indian languages, including Hindi, Tamil, Telugu, Malayalam, Punjabi, Odia, Gujarati, Marathi, Kannada, and Bengali.

As mentioned in the post, they used Supervised Fine-Tuning (SFT), Reinforcement Learning with Verifiable Rewards (RLVR), and Inference Optimization to train the model.

Trying the Sarvam Playground

I visited this URL to access the Playground and signed up using my Google account, and landed on playground page that looked like this.

I asked it to talk to me in the Hindi language and it immediately replied to me in the language. And it was very fast, definitely faster than ChatGPT and Gemini. If you'd like, below is the exact response that it gave.

But what impressed me the most is its "Text to Speech" tool. When I clicked on the option, it preloaded a line of text in the Odia language and perfectly spoke the language when I clicked on the generate button.

To test further, I gave it the below paragraph in English, asked it to translate to Odia, and then converted it to an audio. I'm putting everything below.

The English text:

The solar system is a group of objects that move around the Sun. The Sun is at the center and is the biggest object in the system. It gives off heat and light that make life on Earth possible. There are eight main planets that go around the Sun: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune. These planets move in paths called orbits.

Translated Odia text:

ସୌରଜଗତ ହେଉଛି ସୂର୍ଯ୍ୟଙ୍କ ଚାରିପାଖେ ଘୂର୍ଣ୍ଣନ କରୁଥିବା ବସ୍ତୁମାନଙ୍କର ଏକ ସମୂହ। ସୂର୍ଯ୍ୟ କେନ୍ଦ୍ରରେ ଅବସ୍ଥିତ ଏବଂ ସୌରଜଗତର ସବୁଠାରୁ ବଡ଼ ବସ୍ତୁ। ଏହା ଉତ୍ତାପ ଏବଂ ଆଲୋକ ବିସ୍ତାର କରେ ଯାହା ପୃଥିବୀରେ ଜୀବନ ସମ୍ଭବ କରିଥାଏ। ସୂର୍ଯ୍ୟଙ୍କ ଚାରିପାଖେ ପରିକ୍ରମା କରୁଥିବା 8ଟି ମୁଖ୍ୟ ଗ୍ରହ ଅଛନ୍ତି: ବୁଧ, ଶୁକ୍ର, ପୃଥିବୀ, ମଙ୍ଗଳ, ବୃହସ୍ପତି, ଶନି, ଅରୁଣ, ଏବଂ ନେପ୍ଚ୍ୟୁନ। ଏହି ଗ୍ରହମାନେ କକ୍ଷପଥ  ନାମକ ପଥରେ ଘୂର୍ଣ୍ଣନ କରନ୍ତି।

And the final audio:

Your browser does not support the audio element.

I don't read the Odia text, but I know how to speak, and can say that the audio quality is very good. It speaks perfectly as they speak on the news channels.

I'm very impressed with the output.

Apart from this, they have other tools like Speech to Text, Speech Translate, Transliterate, Translate, and Language Identification. I tried the Speech to Text tool by uploading the same audio in Odia language, and it was able to transcribe perfectly transcribe it.

Similarly, other tools are good as well.

One problem though, when I put 2 paragraphs of text in the text-to-speech tool, it doesn't work and just says "internal server error". The error should be more descriptive.

Trying via the API

I received ₹1,000 worth of free credits when I created a new account on the platform, so I also decided to try it via the API and see how it performs.

I went through the docs and created a simple interface to try the API using HTML and JavaScript, everything is hard-coded as you can see here:

<!DOCTYPE html>
<html>
<head>
  <title>Sarvam Chat</title>
</head>
<body>
  <h1>Ask Sarvam</h1>

  <input type="text" id="userInput" placeholder="Type your question..." style="width: 300px;">
  <button onclick="callSarvam()">Send</button>

  <h2>Response:</h2>
  <pre id="output">Waiting for input...</pre>

  <script>
    async function callSarvam() {
      const userMessage = document.getElementById('userInput').value;

      const response = await fetch('https://api.sarvam.ai/v1/chat/completions', {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY_HERE',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          messages: [
            { role: 'system', content: "you're sarvam, an llm" },
            { role: 'user', content: userMessage }
          ],
          model: 'sarvam-m'
        })
      });

      if (!response.ok) {
        document.getElementById('output').textContent = 'Error: ' + response.status;
        return;
      }

      const data = await response.json();
      const content = data.choices[0].message.content;
      document.getElementById('output').textContent = content;
    }
  </script>
</body>
</html>

You just need to replace YOUR_API_KEY_HERE with your actual API key, and then you can ask questions and get answers on the page. I tried asking a few questions and it did answer as it does on the playground, the text response from the API is fast as well.

Sarvam API pricing

Below is the pricing for different models in Indian Rupees (₹) as present on the pricing page.

Category	Service	Price
Speech APIs	Speech to Text	₹30 / hour
	Speech to Text & Translate	₹30 / hour
	Speech to Text with Diarization	₹45 / hour
	Speech to Text, Translate & Diarization	₹45 / hour
Language Tools	Translate	₹20 / 10K chars
	Transliterate	₹20 / 10K chars
	Language Identification	₹3.5 / 10K chars
Text to Speech	Text to Speech	₹15 / 10K chars
Analytics	Call Analytics	₹112 / hour

I don't know why they haven't mentioned the pricing for chat completions anywhere on the pricing page, or on any page.

But... do people care about an Indic LLM?

Yes, the question is, do people of India actually need an Indic model like this? Several people like Deedy and Arpit Bhayani mention that there's not enough demand for a model like this and that's why there are only a few hundred downloads of the model on Hugging Face.

I think, main reasons for less number of downloads are:

very fewer people care about LLMs in India as of now
most people are end users and won't be downloading the model from Hugging Face, and
this is not marketed well enough, people need to be made aware of what this can do

Honestly, I loved the model. If I have to make a multilingual website then I would prefer Sarvam-M to translate my content over OpenAI's or Gemini's models without any second thoughts.

🗓️ Update: June 4, 2025

The number of downloads on Hugging Face has increased to 269,186 at the time to writing this post. But I am not seeing enough buzz about Sarvam AI on social media and also on YouTube, so it's hard to say if the number is genuine or manipulated.

Overall, I liked the below things:

ability to generate output in Indian languages
formatting and quality of the output
inference speed when asking questions

And a few things that can be improved:

documentation for different endpoints
making people aware of the model

I also recorded a video of myself trying the new Sarvam-M model via the playground and API, and have put my thoughts into it.

[email protected]/src/lite-yt-embed.min.css">

That's it.

I am still using and testing the model and will keep updating this page if I learn something new.

Trying the Qwen3-8B Model Locally

2025-05-04T02:42:52Z

I have been hearing a lot of good things about the qwen3-8b model lately, in fact, I also read about it in a post by Simon.

So, I had to try it and I will be sharing my learnings in this post.

Installation

I use Ollama so the installation process was easy, I just ran the following terminal command and the model got installed within a minute. You can visit the Ollama page for qwen3 here.

ollama run qwen3:8b

For the 8b model, it downloaded a 5.2GB file.

Initial testing

At first, I just sent "hi" and then only I got to know that it's a thinking model as its thoughts were being shown between <think> </think> tags. And then it replied with "Hello! 😊 How can I assist you today?" as you can see in the below screenshot.

I am using a MacBook M2 Air 16GB device and the evaluation rate was 16.34 tokens per second, as you can see in the above screenshot.

Coding test

I asked it to generate a simple tic-tac-toe game by giving it the following prompt:

create a tic tac toe game in python

And, to my surprise, it created the best tic-tac-toe game I have ever played in the terminal and it ran without any errors. If you want to take a look, below is the Python code that it gave me:

def check_winner(board, player):
    # Check rows
    for row in board:
        if row[0] == row[1] == row[2] == player:
            return True
    # Check columns
    for col in range(3):
        if board[0][col] == board[1][col] == board[2][col] == player:
            return True
    # Check diagonals
    if board[0][0] == board[1][1] == board[2][2] == player:
        return True
    if board[0][2] == board[1][1] == board[2][0] == player:
        return True
    return False

def is_draw(board):
    for row in board:
        if ' ' in row:
            return False
    return True

def print_board(board):
    for row in board:
        print('|'.join(row))
    print()

def main():
    board = [[' ' for _ in range(3)] for _ in range(3)]
    current_player = 'X'

    while True:
        print_board(board)
        while True:
            try:
                move = int(input(f"Player {current_player}, enter your move (1-9): "))
                if 1 <= move <= 9:
                    row = (move - 1) // 3
                    col = (move - 1) % 3
                    if board[row][col] == ' ':
                        board[row][col] = current_player
                        break
                    else:
                        print("Cell already occupied. Try again.")
                else:
                    print("Invalid input. Please enter a number between 1 and 9.")
            except ValueError:
                print("Invalid input. Please enter a number between 1 and 9.")

        if check_winner(board, current_player):
            print_board(board)
            print(f"Player {current_player} wins!")
            break
        if is_draw(board):
            print_board(board)
            print("It's a draw!")
            break
        current_player = 'O' if current_player == 'X' else 'X'

if __name__ == "__main__":
    main()

It looks like this when you play the game - it perfectly handles the win, lose, and draw cases.

| | | |
| | | |
| | | |
Player X, enter your move (1-9): 1
|X| | |
| | | |
| | | |
Player O, enter your move (1-9): 5
|X| | |
| |O| |
| | | |
Player X, enter your move (1-9): 3
|X| |X|
| |O| |
| | | |
Player O, enter your move (1-9): 7
|X| |X|
| |O| |
|O| | |
Player X, enter your move (1-9): 9
|X| |X|
| |O| |
|O| |X|
Player O, enter your move (1-9): 4
|X| |X|
|O|O| |
|O| |X|
Player X, enter your move (1-9): 6
|X| |X|
|O|O|X|
|O| |X|
Player O, enter your move (1-9): 8
|X| |X|
|O|O|X|
|O|O|X|
Player X, enter your move (1-9): 2
|X|X|X|
|O|O|X|
|O|O|X|
Player X wins!

But the only issue was, it took approximately 12 minutes to give the output as it kept thinking and thinking. I am sure that it's due to my computer's power, and it would have been faster on a computer with higher configuration.

If you want to take a look at the entire output, including the <think> tags, you can click here to see this .txt file.

Apart from this, I asked multiple simple coding and tech related questions and I'd say that I am very satisfied with it. It performs surprisingly well for its size.

Learning about sqlite3 WASM

2025-04-24T01:22:40Z

I love sqlite3 and have used it for a few simple projects, but I recently came to know that Notion uses sqlite3 WASM in the browser for client-side caching – they have been able to improve their page navigation times by 20% by doing so.

I found it really interesting, so started reading more about it. Basically, this post is just my notes on the topic – I will be noting down whatever I read.

What is sqlite3 WASM?

sqlite3 WASM or WebAssembly is a version of the SQLite database that’s built to run in web browsers using WebAssembly. It lets you use a full SQLite database directly in the browser, powered by JavaScript and compiled C code, without needing a server.

And this version is officially supported by the SQLite team.

Features

Runs the complete SQLite engine within the browser using WebAssembly while supporting standard SQL queries and database operations without server-side components.
Supports multiple JavaScript APIs, like:
- Low-level C API binding that provide direct access to SQLite's C API
- High-level object-oriented API that offers a more JavaScript-friendly interface
- Worker-based API that enables operations in web-workers to prevent blocking the main thread
- Promise-based API that simplifies asynchronous operations with a Promise-based interface
Utilizes the OPFS (Origin Private File System) for persistent storage, so that the data remains available across sessions.
Allows the creation of virtual tables and table-valued functions directly in JavaScript and also supports custom builds with additional features or optimizations.

How Notion is using it

Earlier, Notion was using IndexedDB for storing data in the browser but it had issues like storage limits and inconsistent performances across different browsers, so they switched to sqlite3 WASM solving all these issues.

Notion uses OPFS to store data locally - persistent across sessions
To avoid slowing down, they run database operations in Web Workers in the background
Only the active tab handles all database writes, and other tabs send their request to this active tab

Here's how they explain this:

[...] only one tab is permitted to actually use its Web Worker. A SharedWorker is responsible for managing which is the “active tab.” When the active tab closes, the SharedWorker knows to select a new active tab.

To execute any SQLite query, the main thread of each tab sends that query to the SharedWorker, which redirects to the active tab’s dedicated Worker. Any number of tabs can make simultaneous SQLite queries as many times as they want, and it will always be routed to the single active tab.

I also found a great discussion on the topic on GitHub that you must check out.

I recommend reading the blog post by Notion as they have explained all the issues they were encountering and how they fixed it.

Who uses sqlite3 WASM

Some notable examples would be:

Notion: as we already discussed in the post
SQLime: an online SQLite playground that runs entirely in the browser
Evolu.dev: a local-first platform designed for developers

Resources to learn more

That's it.

I will be reading more about it, and will keep this post updated.

Trying the LibreWolf Browser

2025-04-18T02:03:55Z

While browsing the r/browsers on Reddit, I came across the name LibreWolf multiple times and then I finally decided to give it a try. Earlier, I tried the Ungoogled Chromium browser and it was unable to become my default browser for certain reasons.

This is not going to be a very technical post, instead, I will just be sharing my experience about what I liked and disliked. So... let's start from the start.

1. Installation

I am using Macbook Air M2 and the installation process seemed straightforward initially. I could install it through Homebrew by running the following command, or download the .dmg file and then install.

brew install --cask librewolf

I used the Homebrew method and it got installed after a minute. But when I tried opening the app, it didn't open and showed the following error dialog. For your information, currently, I'm on the latest macOS Sequoia 15.4.1.

I started looking and found this Reddit thread, tried a bunch of things, and finally found a solution. I have briefly explained about the same in this post.

Finally, I got it to open.

2. Things I liked

I liked how clean it looked, but I went one step further and disabled shortcuts and recent activity from showing on the homepage and then looked even cleaner.

Now, let's go through the things I liked.

Comes with uBlock Origin preinstalled

Yes, I didn't even have to install an adblock extension as it already came with uBlock Origin extension installed. The extension was also already pinned to the toolbar, as you can see in the top-right of the above screenshot.

In fact, after Google Chrome started enforcing the Manifest v3 for extensions, most of the Chromium-based browsers don't support the uBlock Origin out of the box now. And as LibreWolf is Firefox based, that's not an issue here with the extension.

Supports Firefox sync

It needs to be enabled from the settings, but the browser does come with the Firefox Sync feature. After enabling it, you can sign in to your Firefox Sync account or create a new account, and the sync starts working.

You can also copy-paste this about:preferences#sync in your address bar and it will take you the sync page. But obviously, it's optional.

Vertical tabs

I am not a fan of vertical tabs but I liked that it has the option to switch between horizontal and vertical tabs with just a click.

For this, you'd go in the Browser Layout section on the about:preferences#general page, as shown above. From here, the sidebar can also be enabled.

Forces web content to use light theme

By default, the ResistFingerprinting feature is enabled so the browser doesn't let website see your device settings (whether it's on dark/light mode) and forces websites to show their content in the light mode only.

I prefer light mode, so it's not a problem for me. But if you don't like, you will have to disable the feature and that will make the browser a bit less secure.

Hardened security settings

I really liked how the security on the browser is super-hardened out of the box.

For example, the "Delete cookies and site data when LibreWolf is closed" feature is turned on by default, means, all cookies will be cleared when you close the browser and you will be logged out from all websites. I don't need this, so I have disabled it.

Similarly, there are other options also that I liked:

Multiple DNS over HTTPS providers
Ask to save passwords, addresses, and payment methods is turned off by default
HTTPS-only mode is enabled

Multiple profiles option

Though the profiles option needs to be turned on manually, it's a great feature. I had to go to about:config, search for browser.profiles.enabled, and set it to true.

I created 2 profiles – personal and work, and gave different colors to each so that they are easily identifiable. Also, I really liked the fact that both profiles open as separate apps, I have added them both in the Dock and can open any profile with just a click.

I found this Reddit discussion to be very helpful when doing all this.

3. Things I didn't like

Apart from the things liked, I also didn't like the fact that "profiles" option is not turned on by default.

That's it.

Update:

To be honest, security-wise, I liked LibreWolf the most out of all the browsers I have used as of now.

But I found the profile switching and Dock icons for different profiles to be buggy. For example, if I open two different profiles then I see two different icons in the Dock, great, but when I close both profile Windows, clicking on Dock icons do not open different profiles.

Sometimes, it becomes very confusing.

For now, I am sticking with the Brave browser, until I find something else.

Trying the Ungoogled Chromium Browser

2025-04-10T14:16:02Z

So... I tried switching to the Ungoogled Chromium browser as my main browser, instead of the Brave browser that I had been using before. To be honest, I sometimes find Brave’s push for crypto and AI a bit annoying, and that’s what made me look for an alternative. I’ve tried a few browsers before, so this time I thought I’d give Ungoogled Chromium a shot.

In this blog post, I will explain the installed process, first impressions, what I liked, what I disliked, and whether I will be using this as my main browser or not.

The installation process

I am, currently, using the MacBook Air M2 as my main computer and the installation process was very easy. I installed the ungoogled-chromium version via Homebrew by running the following command in the terminal, which took around 30 seconds to complete.

brew install --cask ungoogled-chromium

I opened the browser, and was greeted by this ungoogled-first-run screen that you can see in the screenshot below. It looked very clean at first and I wasn't asked to log-in in order to sync my settings as Google Chrome normally does.

Now, it was time to test it properly.

Testing as per my use-cases

1. Changing the default search engine

At first, there was no default search engine set so I opened settings and selected DuckDuckGo (which was pre-listed among among Bing and a few others, but no Google) as my default search engine. By the way, one can also add Google Search by clicking on the Manage search engines and site search button.

2. Installing Chrome extensions

I visited Chrome Webstore and opened random extensions, but wasn't able to install as it was showing an error of "Item currently unavailable".

I directly visited the uBlock Origin's GitHub repo and downloaded the .zip file for the Chromium build. The extension got installed with no errors and was working perfectly as well.

However, I noticed their instructions that explained a way that enables the Ungoogled browser to install any Chrome extension like you normally do. For that, I had to enable a flag in the chrome://flags and install a Chrome extension called chromium-web-store.

After following the steps, "Add to Chrome" button started showing on all extensions from the Chrome Webstore, as you can see in the screenshot above. By the way, X Mute is a Chrome extension that I have created – it can mute multiple words/phrases on X (Twitter) at once, and not to mention, it's free to use.

3. Profiles and developer tools

Somewhere I read that the Ungoogled Chromium browser doesn't support creating multiple profiles, but that's not true now. I successfully created two profiles named personal and work.

I also tried opening the developer tools and it worked as expected – just like how it does in the Google Chrome browser.

4. Gmail and YouTube

I also logged into Gmail and it does work, and it stays logged in even after I quit and re-opened the browser. YouTube works perfectly as well, no lags, or no missing features - theatre and fullscreen modes worked as well.

I also logged into X (Twitter) it also worked as expected.

5. Secure DNS and Google

I didn't expect that the "Use secure DNS" feature would be there in the browser, but it was there and worked as expected. I normally use the Cloudflare's 1.1.1.1 DNS resolver which reduces the latency a bit and also makes everything neutral. I was able to turn it on and use it.

Also, I noticed a funny thing that it says "You and Google" but Google Sync doesn't work as it's disabled (which does make sense).

6. DRM issues

I tried opening a few Udemy courses to test the DRM features and it didn't work. Some courses played without any issues, but DRM protected courses didn't play, even after trying multiple times.

The workaround could have been to follow this tutorial on their FAQ page, but I didn't have that much patience. It's something like, you'll have to download the Google Chrome official installer file, mount it, and run a terminal command to install the Widevine CDM.

7. Benchmark testing

I used the BrowserBench Speedometer to run tests on the Ungoogled Chromium I installed and also on the Google Chrome browser that I already had installed. To my surprise, Google Chrome scored a bit higher than the Ungoogled browser.

The left is Google Chrome stat (33.0) and the right is the Ungoogled Chromium stat (31.2). But I don't think, it's a deal breaker as the difference is not much.

8. Experienced a bug

Lastly, I experienced a weird bug as well. The uBlock Origin extension that I installed manually, automatically got uninstalled when the quit the browser using cmd + q and re-opened it. I installed the extension again and then it again got uninstalled.

This bug has now made it a difficult choice for me to permanently switch to this browser. But I am still testing it for a few days, and let's see if I change my mind.

For now, I will keep using the Brave browser.

Update: Apr 18, 2025

After using the browser for more than a week, I have decided not to use this as my default browser, in fact, I have uninstalled it. And the main reasons are minor bugs that I mentioned, and also the very late security updates.

After this, I will be trying the LibreWolf browser and let's see if that meets my expectations.

MP3Detective: AI-Powered Music Metadata Manager

2025-04-06T02:31:03Z

I have a huge collection of MP3 files for Hindi songs, and most of them have incorrect or missing metadata (like song name, artist, album, etc.). I tried many online tools but none of them worked well, especially for old Bollywood songs.

So, I decided to build my own tool using OpenAI's GPT-4o model. And... say hello to MP3Detective – a Python tool that automatically finds and updates MP3 metadata.

How it works

The tool is quite simple. You just:

Put your MP3 files in the input folder
Run the Python script
Get your updated files in the output folder

The best part? It works with any language or music genre. I tested it with my old Hindi songs collection, and it worked with about 95% accuracy. Yes, it did make some mistakes with very old or rare songs, but that's expected.

I also have a quick video showing how it works:

[email protected]/src/lite-yt-embed.min.css">

Building the tool

I used Python to build this tool because it has great libraries for handling MP3 files. The main pieces are:

OpenAI's GPT-4o for identifying song details
eyeD3 for reading/writing MP3 tags
tqdm for showing nice progress bars

Here's the folder structure of how everything is placed:

mp3detective/
├── .gitignore        # Git ignore rules
├── app.py            # Main application file
├── requirements.txt  # Python dependencies
├── README.md         # This documentation
├── input/            # Place your MP3 files here
└── output/           # Updated files will appear here

The tool creates a copy of your original files, so you don't lose anything. It also keeps a detailed log of what it's doing, which helps if something goes wrong.

Real-world testing

I tried it with about 1,500 old Hindi songs first. Here's what I found:

For most songs, it found the correct details
Some very old songs (1950s-60s) were tricky
Sometimes it couldn't decide between two similar song versions
The original files stayed safe in the input folder

And this is what it shows in the terminal after the process finishes.

Using it yourself

Want to try it? It's pretty simple:

Get the code from GitHub
Install Python if you don't have it
Add your OpenAI API key
Put your MP3 files in the input folder
Run the script

That's it! The tool will do its magic and you'll find your updated files in the output folder.

The code is open source, so feel free to try it out or even make it better!

Running Ollama in Android Linux Terminal

2025-03-18T13:47:49Z

I had this random thought of running Ollama inside the new Android Linux terminal, so I tried running the small gemma3:1b model and it did run successfully. I also recorded a quick video which you can watch here.

[email protected]/src/lite-yt-embed.min.css">

Now, let me document exactly what I did:

1. Install Ollama

I installed Ollama in the terminal by following their official guide to install on Linux. Basically, I just ran the following command:

curl -fsSL https://ollama.com/install.sh | sh

At the first try, the install failed for unknown reasons, so I increased the disk size from the Disk Resize option under the gear icon in the terminal. And then running the above install command did work, for whatever reasons.

I, then, ran the ollama command and it showed me all the available options, as you can see in the screenshot here.

2. Running the `gemma3:1b` model

I looked for a lightweight model on ollama.com/search page and found the gemma3:1b to be a suitable one – it was 815MB in size which was manageable. First, I ran the pull command and then the run command:

ollama pull gemma3:1b

ollama run gemma3:1b

I did not directly run the run command because terminal was immediately crashing after running it.

It took multiple tries, I had to run the following commands and then close-open the app multiple times:

sudo systemctl daemon-reload

sudo systemctl enable ollama

sudo systemctl start ollama

And then it finally started running...

droid@localhost:~$ ollama run gemma3: 1b
>>> hi
Hi there! How's your day going so far?
Is there anything you'd like to chat about or any help I can offer?

I said hi to which it replied as you can see above but the terminal crashed immediately after. I tried opening it again 2-3 times, but it didn't open. I had to erase all terminal data and reinstall Ollama, but then it crashed again after just a hi.

Clearly, the Android Linux terminal is not very stable at the moment but it's a good start. I am very hopeful about this, and I'm sure it will only improve in the future.

Update:

I got experiment some more and now Ollama is properly running for models like qwen2.5:0.5b and qwen2.5-coder:0.5b as they are significantly smaller than the 1b models that I was trying to run earlier. I have also recorded a new video for this:

I asked a bunch of questions, and the terminal is not crashing this time.

Life with a Fractured Leg

2025-03-16T07:35:45Z

Almost 10 days ago, I suddenly got this idea to play badminton and asked my friend if he would join a court with me. He agreed, and we got ourselves admitted to a court nearby the same day, and started playing from the next day.

It was fun... while it lasted.

I got my leg fractured on the 3rd day after joining the court. Yes, it was my mistake but I was running towards the right to hit the shuttle and suddenly tripped while twisting my right leg. I felt an unbearable pain near my ankles and I sat down immediately.

I stayed there for some time, and then somehow got myself home with the help of my friend. And the visit to the doctor revealed that there's a minor fracture between the end of second and third toes (you can probably see that in the x-ray report below) – it's like zig-zag.

I was scared a bit, but didn't think the doctor would recommend getting a plaster (cast) done to the leg. I thought, some crepe bandage would do the job, but... happened otherwise. They used some kind of synthetic cast tape which solidifies within minutes after applying. You can see how it looked at the time – just after the tape was applied.

You know, it was funny that I wore tight pants to the doctor, and I had to cut them to remove after the cast was applied.

Initially, it was very uncomfortable to even walk a step, but now I've gotten acquainted with it as it's been a few days. I can slowly walk to the washroom, kitchen, work setup room, and towards the main door for my daily works. It's just that I can't cook anymore and it's okay, Swiggy, Zomato, and BigBasket are of big help here.

But it has to go on for 30 days – another 25-26 days to be precise.

The good thing is, I can still work. I can comfortably sit in front of the computer for as long as I want, and do whatever (guess what, I'm using Cursor AI a lot these days). Life's been a bit slow, but it's giving me a lot of time to think:

that how uncertain life is – anything can happen to anyone
you do not always get what you plan for, so shouldn't take life that seriously

But... I'm good.

Still learning new things, working, having fun, and enjoying this part of the life. Actually, I am sleeping a lot more these days and the health is good as well. Sometimes, I also play games on my phone especially the Mini Militia game, and loving it.

It seems like nothing bad has happened, I am already adapted to this new temporary style of life.

Clearly, whatever happens, life goes on!

And... I will be playing badminton again. For sure.

Trying Out the New Android Linux Terminal

2025-03-12T04:39:15Z

I heard about this news of Google preparing to let you run Linux apps on Android back in October, 2024. And then, a few days ago, I learned that it's actually live on Android 15... so I had to try it out.

To enable this, I had to go into the Developer options in Settings and then enable the Linux development environment option. It downloads some ~500 MB of data before the terminal actually starts.

Yes, I installed neofetch and htop and you can see how it looks above. Cool, right?

And then I suddenly got an idea to install Node.js and run a basic Next.js app, and it just took me ~5 mins to install everything and the app was running. I even recorded the screen with a bit of commentary that you can watch here.

[email protected]/src/lite-yt-embed.min.css">

At the very first, I installed the nodejs and npm by running below commands one by one (as you will see in the video above):

sudo apt install nodejs

sudo apt install npm

I, then, directly ran the below command to set up a new Next.js application, and it worked. As it was just a test, I just chose all the default options and everything was ready.

npx create-next-app@latest

Lastly, I ran the npm run dev command inside the project folder and the app was running. I clicked on the Network link (http://192.168.0.2:3000) and the app opened (you'll my excitement in the video).

Now, let me address some common questions about the new Android Linux terminal:

1. Can I install GUI on it?

No, sadly, you cannot install any Desktop Environment on it as Google has already made clear. Actually, I tried running the sudo tasksel command but nothing happens.

2. Can I install GUI apps on it?

No, you can't run GUI apps either. For example, I installed the VS Code editor, but it doesn't open, even if you run the code . command inside a folder.

3. What are the benefits of the native terminal over Termux?

The only benefit that I see is that you can install packages directly from the sudo apt install <package name> command. You have access to 10,000 or even more apps (but only terminal apps/tools will actually run).

And if you want to learn more about this, I found a detailed post discussing this that you can refer to.

4. How's the opening speed?

It's slow – takes somewhere from 10 seconds to 20 seconds on my Pixel 7a device. Unlike Termux, it runs using KVM and that's the reason it's slow.

5. Can the terminal access Android files?

It can access your Android's device downloads folder, but cannot access other folders or files. To access the download folder, you need to run the below command:

cd /mnt/shared

I have created another video where I am using the Linux terminal and showing what it can do and what it cannot. It's a quick fun video, so do give it a watch.

Also, I tried running local AI model gemma3 via Ollama in the terminal, and it runs.

Update: Apr 4, 2025

I received an email from a person asking about an issue that wasn't able to install any tools. For example, the person was trying to install neofetch and it was constantly showing errors, as you can see explained in the screenshot.

After exchanging a few emails, we finally learnt that the terminal didn't have internet access when the device was connected to the cellular data. And connecting to the wifi did solve the problem.

Update: Apr 15, 2025

I received another email where the person got the internet working by using the cellular data, below is how you can do it too.

To access the internet when the device is connected to the cellular data, you need to go to Terminal's Settings (long press on the Terminal app icon and then click on the i button), and turn on the Unrestricted mobile data usage under Mobile data usage.

The setting might be at a different location depending on your device, but basically, you have to unrestrict the mobile data usage. Then restart the device, and it should work.

That's it.

It's just the start, and I'm sure the Linux thing will become even more powerful in the near future. I am really really excited for it.

Optimizing 1,300+ Images using 'sharp'

2025-03-08T05:06:12Z

I found out about the "sharp" image library when I was migrating my website from WordPress to 11ty, as it was mentioned somewhere on the 11ty documentation page. And coincidentally, only a few days later, I had to optimize over 1,300 images for a project and I immediately moved to using sharp.

I even created a GitHub repository (have named it OptiSharp) and have put all the code there. You can also watch this quick video to understand how it works.

[email protected]/src/lite-yt-embed.min.css">

How OptiSharp works

OptiSharp is a simple tool that makes your images smaller and better for the web. Here's how it works:

#1. Put your images in: Just drop all your images into the input folder.

#2. Choose your settings: You can easily change a few settings like:

How small you want the images to be
What type of image you want (JPEG, PNG, WebP, etc.)
How good the quality should be
If you want to keep the image information (like camera details)

#3. Run the tool: Type one command, and it will:

Look at all your images
Make them smaller
Save them in the output folder
Tell you how much space you saved

#4. Get results: After it's done, you'll see:

How many images it processed
How much smaller they are now
How long it took
If there were any problems

Why I made this

I needed to make lots of images smaller for websites, and doing it one by one was taking too long. Most online tools:

Only let you do a few images at a time
Have size limits
Sometimes make you pay
Don't give you many options

OptiSharp solves these problems because it:

Can handle hundreds of images at once
Works on your own computer
Is completely free
Lets you control exactly how you want to change your images

How to use it

Make sure you have Node.js on your computer
Download OptiSharp from GitHub
Put your images in the input folder
Run the program
Get your optimized images from the output folder

It's that simple! The tool will show you how much space you saved and if there were any problems.

What's next?

I'm planning to add more features like:

A simple screen where you can change settings without coding
More ways to make images look better
Ability to rename files automatically

If you want to try OptiSharp, visit the GitHub page and follow the instructions. It's free and open for everyone to use and improve!

Taking Notes in VS Code

2025-03-04T16:11:13Z

I have tried many different tools and apps for taking notes, but recently I started using VS Code to take notes as markdown files, and I am really enjoying it. I tweeted about it when I started and now it's been more than a month, and I'm still use the notetaking setup.

While I use Notion to manage most of my "business" stuff, I've started taking plaintext notes in Markdown format for my "personal" stuff.

Simply using the VS Code editor for this, along with a few tools:

1. Markdown All in One – for better Markdown support when editing

👇 pic.twitter.com/Scr4YGO6nr
— DeepakNess (@DeepakNesss) January 19, 2025

In the past, I have used tools like:

Notion
Evernote
Standard Notes
Simple Note
Logseq
Joplin
Obsidian
Notion, and more.

And now using the simple VS Code and organizing them by creating different folders and files as needed. I love Obsidian as well, but honestly, I got bored and just wanted to try a new setup.

Now, let me showcase my setup, including how I am using it.

The setup

My current setup is simple, I have a folder opened in the VS Code editor where I create .md files for each new topic and then write everything in plaintext, as you might be seeing in the screenshot below. For images and other files, I have a folder called files where I can copy-paste any kind of file that I want to refer to in my notes.

I do not use Copilot's AI features while writing, because I believe that writing should be distraction free and getting auto-completions and suggestions are distracting. But I do use some extensions to make my writing experience better:

1. Code Spell Checker

Sometimes, I also publish some of notes online so I can't have minor spelling errors. And that's why extension called Code Spell Checker comes into play. It doesn't distract, but firmly highlights words with incorrect spellings.

2. GitDoc

All notes are offline, but can't afford to lose them and this extension helps me automatically push new changes to a private GitHub repo every 30 seconds.

3. Markdown All in One

This extension is the best, it simplifies the markdown writing process for me. For example, if I type - to get into the unordered list mode, it detects that and pressing Enter creates a new list item. It's also super helpful for creating Markdown tables.

Apart from these, I have Atom Material Icons and Theme installed in the VS Code which I like a lot.

Creating My First Chrome Extension

2025-02-22T15:01:41Z

I am not a developer but I tried building a Chrome extension 4 years ago, but couldn't complete the project as I encountered so many errors and issues. But the idea of creating simple Chrome extensions stayed with me.

And... allow me to introduce X Mute – a Chrome extension that helps you clean your X (Twitter) feed by allowing you to mute multiple words at once. Currently, you need to mute words one-by-one on X, but the extension can block tens of words in no time.

As you can see in the above screenshot, you can copy-paste multiple comma-separated words/phrases at once, select right settings and just click the Start Muting button. It mutes all the provided words one-by-one.

Getting started with building

A few days ago, I tweeted this idea and started building it by myself a few days later (yes, this post is about that only).

IDEA:
Create a Chrome extension that allows you to add a list of words or phrases and automatically adds all of them to the mute list.

Currently, you have to mute words one by one. https://t.co/noe63CM0Af
— DeepakNess (@DeepakNesss) February 16, 2025

But this time, I took help of AI to build the extension – the mighty Cursor AI. It took me a few hours to to complete the initial version, but it was worth it. You can see the screenshot of my Cursor IDE setup.

In the first prompt itself, I provided the HTML snippets of X page to mute words so that Cursor can auto-select the required CSS Selectors from the code, and it did that. The basic version of the extension was ready in the first two hours itself, and then I spent the next few hours tweaking the code to make polish the UI and UX a bit.

The same day, I even created the Chrome developer account and tried getting myself verified by paying $5 and submitting my IDs. They said that they'll get back in the next few days, so then I started working on the landing page that I, again, created using Cursor. It took me around 1.5 hours to complete the landing page using Next.js, and I chose Next.js because the mute words list project was already built using the same tech stack.

Then, I called it a day and started waiting for the next day... to get verified.

Submitting to Chrome Webstore

The very next day, my Chrome Webstore developer account actually got verified and I received the below confirmation email.

The next step was to submit the extension as a .zip file along with proper description, screenshots, and logo.

For the screenshot, I just opened the "popup.html" in Chrome and did some minor CSS changes to make it appear in the middle and then took the screenshot.
For the description, I asked Cursor itself to generate a solid description for the extension and then copy-pasted the same while submitting. I also had to provide Permission justification which Cursor wrote for me.
For the logo, I got this flower like SVG icon from Reshot and just edited the color to match the website's theme.

Then I hit the Submit for review button and started waiting for the good news.

Getting rejected

The very next day, I received an email (see screenshot) saying that the submission was rejected due to some kind of violations.

Upon looking, I discovered that I was requesting an additional "scripting" permission in the manifest.json file but that permission wasn't getting used for anything. I provided the rejection email to my developer, Cursor, and asked it to fix the issue. Cursor also agreed that the "scripting" permission was unnecessary and can be safely removed without harming any of the features.

I re-submitted the fresh .zip file and started waiting for the updated. I kept refreshing my emails but didn't receive a reply for the next few days.

Live on Chrome Webstore

After 4 days, I received the email (see screenshot) that I was waiting for – my submission was accepted and the extension was live on the Webstore.

It's just the very first version of the extension, and I will be further improving it by adding more features and making it even more user friendly.

And now that I have a little bit of understanding how Chrome extensions are developed, expect more cool extensions coming from my side.

That's it.

Better YouTube Embeds ~77% Faster

2025-02-14T17:35:50Z

I was using the iframe to embed YouTube videos to my blog posts, and it was significantly slowing down the website. I started looking for a way to optimize the loading of embedded videos and have finally found a solution.

But before I start explaining, first, take a look at the GTMetrix loading chart before I implemented the solution. It was taking 3.6 seconds to fully load the webpage, which is just too much.

But after I implemented the solution, the same webpage now takes 0.78 seconds – almost 77% faster than earlier.

Introducing `lite-youtube-embed`

While looking for a solution, I came across this GitHub repo called lite-youtube-embed that had the exact solution what I looking for. And then I found out that someone has also created a 11ty npm package for the same that I can install and use (for context, I recently moved this site to 11ty).

Initially, it only loads the video thumbnail with an YouTube play icon over it, and necessary scripts are only loaded someone clicks on the video. So... this makes the initial loading faster.

The installation process was fairly easy, first, I just ran the following npm install command and then added it to the Eleventy config file.

npm i eleventy-plugin-embed-everything

# Import at the top
import embedEverything from "eleventy-plugin-embed-everything";

# Add below somewhere inside "export default async function(eleventyConfig)" function
eleventyConfig.addPlugin(embedEverything, {
    youtube: {
        options: {
            lite: true
        }
    }
});

And... it was working.

Make sure, lite is set to true as you see above.

Earlier, I had to manually copy the iframe embed code from YouTube in my .md file which looked like this:

<iframe width="560" height="315" src="https://www.youtube.com/embed/H21-e-zy-b8?si=eJzwJ0Xfc53dxy7y" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

But now?

## Lorem ipsum dolor sit amet.

https://www.youtube.com/watch?v=H21-e-zy-b8

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a urna ut massa tempus varius sit amet vel eros.

I can just paste any YouTube video URL directly in the Markdown, whether it's short or full URL, and it gets embedded.

I'm NOT Blocking AI Crawlers, For Now

2025-02-12T05:39:31Z

During the middle of last year, Cloudflare introduced a new button called "Block AI Bots", designed to block all AI crawlers. It’s available even on their free-tier plan, and you can enable it with just one click.

I love it! But I'm not using it.

While I think it’s a great feature, I’ve decided not to enable it on my websites—and I have good reasons. AI assistants like ChatGPT are already driving a significant amount of traffic to my projects. For example, the website shown in the Google Analytics screenshot below receives around 450 visits per month from ChatGPT alone, and I’m happy with that.

The future of AI and content

Looking ahead, I believe avoiding new technologies will only hurt us rather than help us. AI is one such technology that we shouldn’t resist—we should embrace and adapt to it.

However, if you create content that takes a lot of effort and you want to keep it exclusive to your audience, then blocking AI bots might be the right choice for you.

There’s also an ethical concern that if AI companies are "stealing" copyrighted content without permission, that’s a serious issue. We need a proper system where authors receive due credit if AI models use their work.

For now, I’m allowing AI crawlers because they benefit me. But if I find out in the future that they’re using my content without proper attribution, I won’t hesitate to block them.

Create New Posts Faster in 11ty

2025-02-06T14:19:26Z

I recently moved my personal blog from WordPress to 11ty and also documented the entire process in a video. I like the current setup in 11ty, but there's an issue...

It takes me a lot of time to create a new blog post, as my blog posts are organized in content/blog/<new-post> folders, as you see in the below screenshot.

As of now, just to create a new blog post, I have to open multiple folders, create the markdown file, and the write all frontmatter properties. And it takes a lot of time.

So... I asked Cursor AI to create a Node.js script that can do all that with just a single command. If you prefer, you can watch this video or continue reading below to learn more.

[email protected]/src/lite-yt-embed.min.css">

I just asked Cursor composer to create a Node.js script where I can run something like node create.js new-post and it should automatically create a new file index.md in the specified sub-folder in the content/blog folder. And also asked it to auto-populate the frontmatter properties like title, description, date, and tags.

If you want, below was the exact prompt that you will also see in the above video:

Write a node.js script that creates new blog posts in content/blog folder.

node create.js rise-of-cursor

if i run a command like above, it should create a new folder in the content/blog folder and then create a index.md file and then populate title, description, tags, and date properties for the frontmatter.

When I ran the terminal command, it gave me an error which I just copied-pasted to Cursor and asked it to fix the issue. And then it provided me with the working script, which is below:

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

// Get the current directory using ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Get the slug from command line arguments
const slug = process.argv[2];

if (!slug) {
    console.error('Please provide a slug for the blog post');
    console.error('Example: node create.js my-new-post');
    process.exit(1);
}

// Create the blog post directory and content
const blogDir = path.join('content', 'blog', slug);
const indexFile = path.join(blogDir, 'index.md');

// Create directory if it doesn't exist
if (!fs.existsSync(blogDir)) {
    fs.mkdirSync(blogDir, { recursive: true });
}

// Generate the frontmatter content
const title = slug
    .split('-')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');

const now = new Date();
const date = now.toISOString().replace('T', ' ').slice(0, 19) + '+00:00';

const content = `---
date: ${date}
tags:
- blog
title: ${title}
description: Add your description here
---

Write your blog post content here...
`;

// Write the file
fs.writeFileSync(indexFile, content);

console.log(`✨ Blog post created successfully at: ${indexFile}`);
console.log('You can now edit the file to add your content!');

It auto-captures the current date-time as well for the date property, and fills in dummy data for other properties. Now, I can just edit the index.md file and publish a lot faster than earlier.

I think, there might already be a better way to do the same, but this solution is not unproductive either.

Update:

I further enhanced the script to make the workflow even faster. Earlier, once the file is created, I had to manually look through the folders to find the newly created file to start editing; but now, the script also opens the file for editing as soon as it gets created.

I have created a video for the same and have shown how the script works. If you want, below is the complete script:

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { spawn } from 'child_process';

// Get the current directory using ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Get the slug from command line arguments
const slug = process.argv[2];

if (!slug) {
    console.error('Please provide a slug for the blog post');
    console.error('Example: node create.js my-new-post');
    process.exit(1);
}

// Create the blog post directory and content
const blogDir = path.join('content', 'blog', slug);
const indexFile = path.join(blogDir, 'index.md');

// Create directory if it doesn't exist
if (!fs.existsSync(blogDir)) {
    fs.mkdirSync(blogDir, { recursive: true });
}

// Generate the frontmatter content
const title = slug
    .split('-')
    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
    .join(' ');

const now = new Date();
const date = now.toISOString().replace('T', ' ').slice(0, 19) + '+05:30';

const content = `---
date: ${date}
tags:
- interesting
title: "${title}"
description: "Add your description here"
---

Write your blog post content here...
`;

// Write the file
fs.writeFileSync(indexFile, content);

console.log(`✨ Blog post created successfully at: ${indexFile}`);
console.log('You can now edit the file to add your content!'); 


// Open the file in VS Code
const absolutePath = path.resolve(indexFile);
spawn('code', ['--goto', absolutePath], { 
    stdio: 'inherit',
    shell: process.platform === 'win32' 
});

console.log('Opening the file...');

You can edit it as per your requirements and get it working. It will at least save you 30 seconds of your valuable time.

Migrating from WordPress to 11ty

2025-02-03T00:00:00Z

I have been using WordPress for a long time for my personal website. But these days, I love writing and taking notes inside VS Code so thought to move my personal blog from WordPress to the 11ty SSG.

The issue was, I had over 130 blog posts and manually converting them to Markdown and moving them to 11ty wasn't possible. But... I finally got it working, and you're reading this blog post on my new 11ty blog.

So... let me explain the entire process from the start. Here's a video that I recorded:

[email protected]/src/lite-yt-embed.min.css">

You can continue below, if you prefer to read instead.

1. Started with a 11ty starter

Initially, I thought of building the site from the scratch, but later I decided to use the official 11ty starter. I chose the starter theme and didn't build from scratch because it has a lot of featured already built-in, such as:

Tags system
XML sitemap
RSS feed
Image optimization
Better navigation
Fast loading, etc.

If I started from the scratch then it would have taken a lot more time than it did to customize the starter theme as per my requirements.

2. Customizing the starter theme

Once the theme was finalized, I started customizing and tweaking a few things in the theme. I didn't change a lot of things, though. In fact, let me explain what customizations I did.

Added my photo in the header

Adding the photo in the header was the most tricky part, because the pre-installed 11ty Image plugin was automatically optimizing the image and changing the image URL, and the image was broken in production. I spent a lot of time debugging the issue, and finally settled with adding eleventy:ignore in the HTML, as shown below:

<a href="/" class="home-link">
    <img eleventy:ignore src="/img/deepakness.jpg" alt="DeepakNess" />
    DeepakNess
</a>

I could also have removed the image transform plugin, but I didn't want to as it's an amazing tool to optimize images.

Added social links and nav in the footer

Adding the footer navigation was easy, but I had to try multiple different icon community plugins. I finally settled with eleventy-plugin-phosphoricons as it had all social media and multiple different icons available. Below is how it looks in action:

Actually, I used Lucide icons as well, but didn't have the new icon for X (Twitter) so I had to look for an alternative, and Phosphor Icons was the best.

Other minor customizations

Apart from the above major ones, I did some other minor customizations, like:

Removed the Feed link from the header and added the RSS icon in the footer
Changed from showing 3 posts on the homepage to 5 posts
Changed the default font (might change again, though)
Added icons for publishing date and tags inside individual posts
Edited the layout file to include open graph images
Completely removed the dark mode from the index.css file, etc.

3. Moving blog posts from WordPress

I was all set to use the wordpress-export-to-markdown tool for converting all my posts to Markdown. But then I discovered Zach's new video where he demonstrates moving 100s of posts from WordPress to Markdown by using the command line tool @11ty/import.

npx @11ty/import wordpress https://deepakness.com/ --output=content/blog --assetrefs=colocate

I just ran the above terminal command, and all my posts were copied as Markdowns into multiple sub-folders with associated images co-located in those folders. Amazing!

But there was an issue!

The frontmatters of the imported WordPress posts were messy. I didn't want authors and metadata and only wanted title, date, and tags from it. I asked ChatGPT for a Python script that can clean the frontmatter of all .md files across multiple sub-folders, and I got it working on the very first try. Below is the Python code, if you're interested:

import os
import yaml
import frontmatter
from pathlib import Path
from datetime import datetime

def clean_frontmatter(file_path):
    print(f"\nReading file: {file_path}")
    
    # Read the markdown file
    try:
        post = frontmatter.load(file_path)
        print("Current frontmatter:", dict(post.metadata))
        
        # Extract only needed frontmatter fields
        cleaned_metadata = {
            'title': post.get('title', ''),
            'date': post.get('date', ''),
            'tags': post.get('tags', [])
        }
        
        print("Cleaned frontmatter:", cleaned_metadata)
        
        # Create new post with cleaned frontmatter
        new_post = frontmatter.Post(
            content=post.content,
            **cleaned_metadata
        )
        
        # Write back to file
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(frontmatter.dumps(new_post))
            
        print(f"✅ Successfully cleaned frontmatter")
        
    except Exception as e:
        print(f"❌ Error processing file: {str(e)}")

def process_markdown_files(directory):
    # Convert to absolute path if it's relative
    base_dir = Path(directory).resolve()
    print(f"Looking for .md files in: {base_dir}")
    
    # Check if directory exists
    if not base_dir.exists():
        print(f"❌ Directory not found: {base_dir}")
        return
    
    # Count files
    md_files = list(base_dir.rglob('*.md'))
    print(f"Found {len(md_files)} markdown files")
    
    if len(md_files) == 0:
        print("No markdown files found! Please check the directory path.")
        return
    
    # Process each file
    for file_path in md_files:
        clean_frontmatter(file_path)

if __name__ == "__main__":
    # Use absolute path to content/blog/blog
    current_dir = Path(__file__).parent
    blog_directory = current_dir / "content" / "blog" / "blog"
    
    print("Starting frontmatter cleanup...")
    print(f"Script location: {current_dir}")
    print(f"Target directory: {blog_directory}")
    
    process_markdown_files(blog_directory)

Also, the import tool had created an additional blog folder inside the content/blog folder. But that wasn't an issue, I manually copied all sub-folders to the correct folder.

I was surprised that I didn't get even a single error during the cleaning process. AI is getting a lot better at coding these days.

4. Making the website live

I pushed the code to a private GitHub repo and deployed the website on Netlify. The process was straightforward because I already know the process, but the first build time took around 4 minutes which was unusually high. Upon investigating, I found that the Eleventy image plugin transforms all images into multiple different formats during the build process and that takes a lot of time. The more number of images you have, it will take more time.

But the problem was, all images were getting transformed on every build which was unnecessary. I came across this repo while researching, but adding the suggested code in the netlify.toml didn't help me.

Now, the build process is taking approx. 2:50 mins. but it should take even lesser time. When I remove the .avif version and only keep the .webp version, the build process only takes around 30 seconds. It could work, but it'd be better if AVIF version of images are also present.

So... I am still figuring out how to properly set up the cache plugin, and will update this section as I discover more.

I also had to add some 301 redirects as I deleted a few pages that I didn't want anymore. For this, I used the Netlify _redirects file approach.

5. Next steps

While I am pretty much satisfied with how the entire set up is, I still have a few things planned to do. Such as:

Write a Python script that reads all the Markdown files, generates description for each, and then adds it in the frontmatter. I can use OpenAI's gpt-4o-mini model for this, and it shouldn't cost more than a dollar for generating descriptions for all posts I have.
Create a Node.js script that helps me create new posts faster by creating the require sub-folder, the index.md markdown file, and then also creates the frontmatter properties (have successfully created the script).

That's it, for now!

Remote Backup to Hetzner Storage Box via rsync

2025-01-06T08:11:43Z

So just after I figured out how to backup to an external HDD by using rsync, I started researching about ways to backup my computer files on a remote storage. And guess what… I figured out that as well.

Again, I am using my Macbook Air M2 and backing up remotely to a 1TB Hetzner Storage Box, and obviously you can get a bigger box if you have more data.

So… now let’s go through the steps:

Step 1: Order a Hetzner Storage Box

At the very first, order a storage box that fits your needs. I only had a few hundred GBs of data, so I got the 1TB box. You will need to create an account on Hetzner, if you don’t have one already and then just place the order.

It takes some time before they activate your request, and it just took 3 minutes in my case. I received a confirmation email as you see above after the box gets activated.

After you receive the email, it’s time to move to the next step.

Step 2: Get Storage Box details and login via ssh

First of all, open the robot.hetzner.com/storage URL and open the box shown on the screen and you should see something like the screenshot below. You need to turn on the SSH support option.

Click on the Reset password button (see above screenshot) and set a new password to be used later.

And now run the following command in your computer’s terminal. Not to mention, replace uXXXXXX with your actual user name (see above screenshot).

ssh -p 23 [email protected]

It will ask for the password, so provide the password and you should now be logged in. You should now see the following screen.

After logging in, you can run the help command to see the available options. It will be shown like this.

Now, let’s go to the next step.

Step 3: Install rsync on your computer

Although, you can go through their official website, the easiest way is to install via Homebrew on your Macbook by running the following command.

brew install rsync

It will just take a few minutes to get installed and then you can move to the next step.

Step 4: Decide folders you want to back up

I back up my entire Users>deepak folder except a few folders like Library, Applications, etc. You can use the --exclude flag to exclude any number of folders. My final command looks something like this:

rsync -avh --progress -e 'ssh -p23' --recursive --exclude 'Library' --exclude '.*' --exclude 'Applications' /Users/<USERNAME>/ <uXXXXXX>@<uXXXXXX>.your-storagebox.de:<REMOTE_FOLDER>

In the above command, you will have to replace the following placeholders with the actual value:

<USERNAME>: Write the user name of your computer
<uXXXXXX>: Replace this with the user name of your Hetzner Storage Box
<REMOTE_FOLDER>: Replace this with the folder name that you want to save your files in on the storage box

You can either run this command directly, or set up an alias so that you don’t have to run this big command every time you back up.

Step 5: Create an easy-to-remember alias

To avoid typing or copy-pasting the huge command every time, let’s set up an alias. First, open the terminal on your computer and type the following command:

nano ~/.zshrc

Add the below line at the very end of the file with the alias you want to keep. For example, if I keep rsync_hetzner then I would write:

alias rsync_hetzner="rsync -avh --progress -e 'ssh -p23' --recursive --exclude 'Library' --exclude '.*' --exclude 'Applications' /Users/<USERNAME>/ <uXXXXXX>@<uXXXXXX>.your-storagebox.de:<REMOTE_FOLDER>"

Make sure to replace the variables as explained previously in the step #4. After that, save and exit the nano editor by pressing Ctrl + X, then Y, and then Enter.

Then, reload your shell by running the following command:

source ~/.zshrc

And you’re done.

From the next time, you just have to open your terminal and run rsync_hetzner the command and the sync process will start automatically.

Important Notes

However, every time you run the command, it will ask for your Hetzner Storage Box password in the terminal. But if you don’t want to enter the password every time, you can follow this tutorial to set up SSH keys.

Also, you might need to provide Full Disk Access to your Terminal app on your Macbook so that it can access all files and folders. I have explained this in detail in the step #3 of this blog post.

To re-download the backup from the remote storage box to your computer, you will have to run the following command.

rsync -avh --progress -e 'ssh -p23' --recursive <uXXXXXX>@<uXXXXXX>.your-storagebox.de:<REMOTE_FOLDER> /Users/<USERNAME>/

You just have to reverse the order of local folder and remote folder, and it works. And this time you will obviously have to remove the --exclude flags. You will find more about this here.

That’s it.

Hope this helps.

Manual Backup to External HDD using rsync

2025-01-06T05:14:28Z

Earlier I used FreeFileSync to backup the updated files and folders to an external HDD, but I was looking for a better and quicker solution for backups and finally found one. I have used rsync in the past for file transfer but never really thought about this use case of using it to backup laptop’s data to an external drive.

I just run the rsynchdd terminal command, and all updated files/folders and backed up within seconds.

Before I explain my process, currently, I’m on Macbook Air M2 and using the Seagate Expansion 2TB External HDD as the external backup drive.

Now, let’s go through the steps one-by-one:

Step 1: Install `rsync` on your computer

The easiest way to install rsync on a Mac computer is via Homebrew by running the following command.

brew install rsync

But you can visit their official website to learn more about the installation process.

Step 2: Get the exact name of your external drive

You can run the below terminal command to know the exact name, but make sure that your drive is connected to the computer before running the command.

ls /Volumes

Copy the exact name of the drive and move to the next step.

Step 3: Decide which folders you want to back up

I back up the entire Users/deepak folder except a few folders in it that I exclude by using the --exclude flag, so now my final command becomes like this.

rsync -avh --progress --exclude 'Library' --exclude '.*' --exclude 'Applications' /Users/<USER_NAME>/ /Volumes/<EXTERNAL_DRIVE>/<FOLDER>

Here, you will have to replace <USER_NAME> with your computer’s user name, then replace <EXTERNAL_DRIVE> with the name of your external drive that you get from the step #2, and then replace <FOLDER> with the name of the folder that you want to keep in the external drive.

Test the above command and see if those files are being copied in the external HDD or not, if it works then we’re ready to move to the next steps.

You may also need to provide your Terminal app the Full Disk Access by going into the Privacy and Security section in the System Settings app, as you can see in the above screenshot.

Step 4: Create an alias

Now, trying to type or even copy-paste the command from the step #3 every time is a difficult task. So… we’re going to create an alias.

If you use the zsh (default on newer macOS versions), then type the following terminal command:

nano ~/.zshrc

Add the below line at the very end of the file with the alias you want to keep. For example, if I keep rsynchdd then I would write:

alias rsynchdd="rsync -avh --progress --exclude 'Library' --exclude '.*' --exclude 'Applications' /Users/<USER_NAME>/ /Volumes/<EXTERNAL_DRIVE>/<FOLDER>"

Make sure to replace the variables in the above command as explained in the step #3. After that, save and exit the nano editor by pressing Ctrl + X, then Y, and then Enter.

Reload your shell by running the following command:

source ~/.zshrc

And now you’re done.

rsynchdd

Whenever you just type the alias name, i.e. rsynchdd in my case, and press Enter, it’s going to sync all the changes immediately. You just have to connect your HDD to your computer before running the command.

Further, if you want to back up files to a remote storage like Hetzner Storage Box via rsync then I have written another post about this.

That’s it.

Creating a Timeline of WP vs WP Engine

2024-11-02T03:55:36Z

Two weeks ago, I was on a 12-hour train journey and got this idea to create a simple timeline of events of the WordPress and WP Engine conflict out of boredom.

Initially, I just thought to organize all the events for myself so that it’s easier to follow. But later, I bought a domain WPvsWPE.report and did an announcement tweet on X.

The idea was to create a simple timeline of events which looks good on all devices, so I started looking for a timeline template and found one from Cruip that uses Tailwind. I liked the template and chose Astro.build for the website because I learned about it recently and wanted to give it a try.

The final tech-stack I used is:

Astro.build for the website
Airtable for storing the events data, and
Netlify for hosting the site

Also, it became extra easy to use Netlify’s edge functions for SSR of data from Airtable, as I found a really useful GitHub repo for that. It made my job 2-3X easier.

Now, whenever I come across any new development in the WordPress (or, rather Matt Mullenweg) vs WP Engine drama, I just add a new row in my Airtable base (see above screenshot), and it automatically starts showing on the website after some time (I have a 10-min caching set up).

Lastly, I loved working with Astro as it is straightforward and will definitely use this again for my future projects.

Fast Internet, But Sites Open Slow?

2024-09-30T11:45:51Z

If you’re on a blazing fast internet but “some” sites open really slow, most probably, I’m about to solve your problem. In fact, I was having the same issue for a few months and couldn’t find a working solution, until now.

This is straightforward, and you can follow the below instructions to implement this quickly (for macOS):

Open the System Settings app, and navigate to the Wi-Fi area
Click on the Details button to the right of the connected Wi-Fi
Go to the TCP/IP section in the popup that opens, and
Change Configure IPv6 value from Automatically to Link-Local Only

And you’re done!

I got to know about this from the below comment on a Reddit post as I was looking for a solution. The comment is originally for Windows and talks about disabling the IPv6 to get rid of the issue.

So… I searched how can I disable IPv6 on macOS that I am currently using, and got the solution that I have shown in the screenshot. After implementing the solution, I could really feel the difference – sites that used to stuck are now opening without issues.

I got so excited to find a working solution finally that I even tweeted about it, as you can see below.

For some time, I had this problem of some websites opening very slow despite having a fast internet.

Now, after months, I finally found a solution that works.

Click on the Details button of the connected Wi-Fi, then on TCP/IP, and change Configure IPv6 value from Automatically… pic.twitter.com/4CVYiqD8nI

— DeepakNess (@DeepakNesss) September 30, 2024

Why does it work?

Now, the next question is, why does disabling IPv6 solve the problem, at least for me?

I don’t know, honestly!

But I found an interesting post on Reddit that explains it like:

My first theory is while your LAN/local network has IPv6, your ISP may not provide IPv6 globally so you have to relay all traffic from IPv6 to IPv4 with something running NAT64.

But there’s also a slight chance that some things like VPNs might not work after you disable the IPv6. And if that’s the case, you will have to dig some more to find a solution that works for your case.

Experience with 3-day Fasting

2024-09-15T23:30:32Z

So… I decided to do a 3-day or 72-hour fasting after watching the video Fasting for Survival by Dr. Pradip Jamnadas. It’s not like I wasn’t aware of the benefits of fasting beforehand, but the video definitely gave me a fresh perspective and kind of pushed me to start the fast.

Below, I will briefly explain what exactly I did and how my experience was:

Day #1
- I wake up, have a cup of black coffee, and start the fast. For the rest of the day, I’m out to movies and stuff with my friends.
- Have cravings during the lunchtime, as I had to watch them eat. But it’s okay, I didn’t eat anything – just water, occasionally.
- At the dinner time, I don’t feel any cravings at all. It’s surprising.
Day #2
- I wake up feeling fresh, take a 4 kilometers walk in the morning. It was lovely weather, so an added benefit.
- I’m feeling energetic as always, no laziness at all. I couldn’t believe that I haven’t eaten for over 24 hours now.
- At 4pm, I take half a spoon of ORS powder with a cup of water. Didn’t feel the need, but read somewhere that it’s good.
Day #3
- I wake up feeling even more energetic. I even hit the gym in the morning, do some light weightlifting and come back.
- It was Monday, so I worked on a few projects and also read books. Didn’t have cravings for lunch or dinner at all.
- I was functioning as usual, even though I hadn’t eaten for almost 60 hours now.
Day #4
- It’s day #4 morning and time to end the fast. In the morning, I have a cup of black coffee and soupy food after a few hours.
- For the next meal, I am back to what I eat normally when I’m not fasting.

And that’s all.

During the 3-day water fast, I didn’t feel even a bit of weakness or laziness. I was fully energetic and was doing all physical activities as I normally do. Yes, I was drinking at least 3 liters of water every day, though.

Next month, I’m definitely doing it again!

Introducing PutOut – Publish eBooks as Websites

2024-08-22T20:44:13Z

While I’m into blogging and SEO since 2015, I started experimenting with programmatic SEO in early 2022 and created UntalkedSEO to share my learnings as blog posts. I was just documenting everything on the site – from non-technical to technical aspects of pSEO.

A month ago, I decided to compile all my important documentations on programmatic SEO into a nice ebook that anyone can access for free. And luckily, once.com announced their free ebook publishing tool Writebook a the same time, and I was hooked. I prepared the ebook and initially published by using the tool on Hetzner.

Initial version of the ebook hosted on Hetzner via Writebook

Writebook is a great tool that allows you to host it on your own server and even collaborate with multiple people in finalizing the ebook. But… I had to keep paying the server fee of ~$5 every month just to host a static ebook that was rarely going to be updated.

So I started looking for an alternative…

And then the idea of creating PutOut comes into the play. I, along with my friend Rohit, started working on the project and it was live within a week. We used the static site generator called 11ty along with Tailwind and now, it can be hosted on platforms like Netlify, Cloudflare Pages, or even on GitHub Pages for free.

We have created detailed documentation on how to get started with the tool as well. It’s fairly simple and very customizable and also has multiple theme options.

You can check the programmatic SEO ebook here, it’s free.

I, being a non-developer, learnt a lot about developing such a tool and certain other things like:

became versed with the 11ty SSG
understood the Tailwind CSS properly now
learnt to set up a proper GitHub repo
collaborating with multiple people on a project
a thing or two about the design as well
efficiently leveraging AI for coding, etc.

That’s it.

And now that have tasted the blood, I’m not going to stop! 🤩

Overthinking is a Matrix

2024-03-15T09:43:30Z

Ever find yourself thinking too much about something and can’t stop? That’s overthinking. It’s like being stuck in a matrix in your mind, and it happens when you’re not confident about something or have been procrastinating for some time.

Think of overthinking as being trapped in a matrix or a maze. Getting out seems hard, but actually, you can escape this matrix more easily than you think. All it takes is a little nudge to remind yourself to stop worrying and start doing something.

And when you catch yourself overthinking, try to let go of the need for everything to be perfect. Just take a small step towards doing something, anything really. If you’re really stuck, talking to a friend or someone you trust can help a lot. They certainly help you see things differently and get out of the matrix.

So, next time you find yourself going round and round in your head, remember it’s okay to not have all the answers.

Just start small with what you can do right now.

Playing with Local LLMs

2024-02-26T21:56:55Z

After experimenting with OpenAI, Claude, and Gemini Pro APIs, I am now deep into playing with locally hosted large language models like llama2 and mistral. Initially, I thought this wouldn’t be an exciting experiment, but I was wrong… very wrong, actually. For the past few days, I have been using these LLMs on my local machine and trying to see what they can be used best for.

In fact, I was able to get outputs from local LLMs to a Google Sheets file. And I have even recorded a detailed video about it that you can watch here:

I am using LLMs via Ollama because it’s extremely easy to use and manage multiple famous models at the same time. And have put all the involved code from my experiment into this GitHub repository (not to mention, you can access it for free).

Apart from this, I am still looking for better use cases for these large language models. I will also be experimenting with local speech-to-text transcription models like Insanely Fast Whisper. Am I starting to transcribe podcasts? No, but will definitely experiment with something interesting use case.

Let’s see!

Publishing from Obsidian using 11ty

2024-02-16T03:43:07Z

I have been a long-time user of Obsidian for taking notes, mostly for writing my daily journals. And I have been using the tool for several years now, it’s fantastic and better than all other note-taking tools I have ever used.

Today, as I was writing my daily journal, I got a thought what if there’s a way to quickly publish all my writings as blog posts? And I quickly started an experiment.

Since I am already familiar with the 11ty (Eleventy) static site generator, I set up a blog by using a minimal CSS framework called PicoCSS. And as I wanted a clean look, I didn’t use any pre-built themes or starter projects – did everything from scratch. After the project was set up, I opened the same folder as a new vault from my Obsidian desktop app, and it turned out, that I can successfully create new posts from Obsidian now, without the need to open my 11ty code folder.

To enhance the functionalities, I did the following things as well:

Set up the default location for new notes so that all notes I take get saved to the same folder. It will be easier to publish later.
Created an Obsidian template that automatically adds all the required front matter in new posts being created.
Installed the git plugin inside Obsidian so that it automatically keeps pushing new changes to GitHub at a specified interval.

I have made the GitHub repo public, in case you want to access the source code that I was showing in the video above. And you can check the sample site as well:

I spent only a few hours working on it, but there can be several further enhancements made to the publishing flow. For example, the way to add internal links and images can be improved.

I hope this gives you at least some idea to experiment further.

Update: 17 Feb, 2026

I worked on it a bit more and made the following changes to the GitHub repo:

Environment-aware site metadata: moved from static site.json to site.js so SITE_URL can be configured per environment (local/staging/prod).
SEO hardening: canonical URL, OG/Twitter metadata, and dynamic fallback image/description support were improved in the base layout.
RSS feed added at /feed.xml for subscribers and feed readers.
Client-side search added with generated search-index.json + search UI page + JS behavior.
Better post metadata model: support for optional updated and image fields, with these reflected in post rendering and social tags.
Sitemap now prefers updated date (updated fallback to date) for better freshness signals.
Automated quality checks added: frontmatter validation + internal link checking + CI workflow on push/PR.
Small UX upgrades: Search/About links in nav, RSS and GitHub in footer, and polished styles for metadata/search views.

I will keep improving it, but if you have ideas, please let me know.

The Learning Month

2024-01-27T23:57:27Z

Every once in a while, I spend the entire month consuming a lot of content and learning something new that I haven’t properly explored earlier. Though, I am open to learning new things all the time, these learning months are special – I plan them.

Previously, the learning month was around September-October 2023 when I was diving deep into the world of AI and coming up with cool scripts for InvertedStone and also for SnapCloud. And now, February 2024 will be one when I am re-exploring WordPress and how I can build solid listing sites while using the techniques of programmatic SEO.

Been using WordPress for almost a decade, but haven't ever used it to create a listing site.

But now, I am exploring and learning about Custom Post Types and Custom Fields; and how they can be used to create good-looking programmatic pages.

As of now, I'm just consuming lots of… pic.twitter.com/2dVbUaqXXU

— DeepakNess (@DeepakNesss) January 27, 2024

While I have been using WordPress since 2015, I haven’t built complex websites with complex themes and plugins tech-stack. But now I really want to, and you might be feeling my excitement from the tweet above.

So… as per the upcoming learning month’s plan, below is what I will be doing overall. And it’s simple:

Since I am trying to programmatically create a good-looking listing website on WordPress, I will be going through countless videos and forum posts to find the most suitable solution for my use case. As WordPress has tons of plugins and themes that can do the same thing, I will have to find the one that suits the best for my needs.
I will be comparatively less active on social media (unless I plan and schedule my posts in advance before the month starts). But I will definitely be open to suggestions and keep sharing my learnings – mostly on X and LinkedIn.
I will keep working on the existing important projects that cannot be delayed but will not be starting any new projects during the timeframe.
Apart from this WordPress thing, I will also be planning for the upcoming videos for the UntalkedSEO YouTube channel and if I have some time, I will spend some more time to fulfil my learning to code desire.
And yes, I also uninstall most of the time-killing apps from my phone during this time.

That’s it.

Let’s see how it goes. 🤞

How X (Twitter) Helps

2024-01-04T00:53:20Z

I did my very first tweet on June 16, 2024, around the same time when I joined my engineering college. To be honest, I don’t remember the reason for joining Twitter at that time, but I did it anyway.

Hello Twitter! #myfirstTweet

— DeepakNess (@DeepakNesss) June 16, 2014

But no, I didn’t tweet anything significant for the next 3–4 years. I was just a passive consumer of mostly politics and some business-related tweets. And I used to love using the platform back then.

From 2021, I started tweeting some random content about blogging & SEO and noticed some people seemed to like them. It wasn’t working though, after months I only had <100 followers; I kept doing the same either way.

My tweets kept getting better with time!

In early 2022, I got into programmatic SEO, started experimenting with it, and started sharing my learnings on Twitter. In fact, I created an entire blog around programmatic SEO as well.

Introducing "Programmatic SEO OS"!

📅 Launching on Jan 5, 2023.

This is the current draft, but will be adding more info and categorizing it better.

Anything specific that you want me to cover? pic.twitter.com/zynm9hqGPe

— DeepakNess (@DeepakNesss) December 19, 2022

At the end of the year 2022, I even launched the best course on programmatic SEO at the time. And made decent money from it as well.

All because of Twitter!

I love Twitter more than any other social media platform because it truly feels like a business-focused community where people share their learnings. No other platform matches the level of Twitter.

Twitter helps me:

share and validate my ideas
attract like-minded people
learn tips-tricks and productivity
hold myself accountable
aspire to “create” more
connect to nice people
to learn something new
clear my doubts, etc.

Over the years, I have had so many random people supporting me for things I do. And it feels sooooo good.

I am not leaving X (Twitter) ever.

My Work Setup

2023-12-20T01:00:24Z

While most of the time I prefer working on my laptop screen, sometimes, I do use an external monitor when I am multitasking. And below has been my setup for over 4 years now.

In the above photo, you are looking at…

MacBook Air 13 with M2
Samsung 22-inch Monitor
MAONO AU-A04 Microphone, and
Fake plastic plants

I love my current setup and don’t feel the need to upgrade it anytime soon.

Yes, I don’t use a mouse because my work mostly revolves around writing, and not having a mouse doesn’t make a lot of difference. And I’m habituated to this as well.

And I don’t mind all the visible wires as well.

If I decide to upgrade my setup, I would just be upgrading my laptop and maybe… maybe my external screen. Apart from these, everything else would definitely stay the same.

See what I’m doing now!

What You Can Do with Programmatic SEO

2023-11-22T09:44:04Z

Programmatic SEO is a technique to publish multiple dynamic pages at once, but people are often confused about the different things it can be used for.

Hint: pSEO is not just for creating blog posts in bulk.

In this post, I will be explaining different ways you can implement the techniques of programmatic SEO on your website.

Let’s get to it, then…

1. Comparison pages

You can use programmatic SEO to create comparison pages to compare two or more entities with each other, and there are several examples of it. The one simple example that I like is what Web3Forms has done comparing all its competitors, as you see in the below screenshot.

You can compare entities side-by-side in a tabular format or one after another in bullet point format. Not only that, you do the comparisons as a simple blog post as well. And pSEO provides you with the flexibility to do all that easily.

If you create content for promoting affiliate products on your website, then creating comparison pages using programmatic SEO can be a winning strategy in the long run.

2. Alternatives pages

I have seen many companies targeting keywords like alternatives of {competitor} where they would present themselves as the best alternative to their competitors. And if your company has, let’s say, 20 competitors, you can design a good page template and publish all those 20 pages instantly.

The best example is Moosend where it’s targeting its biggest competitors and then presenting itself as the best alternative, as you can see in the above images. Moosend is ranking in the top #5 for most of these terms, and you can imagine how much valuable organic traffic it must be getting.

3. Blog-style pages

Creating blog-style pages is the most common use of pSEO as it’s very simple and easy to set up. If you’re on WordPress, you can easily use plugins like WP All Import to build multiple blog-style pages within no time.

For readers, these pSEO pages seem like simple, manually written blog posts. But for that, you need to have a really great page template designed. The above screenshot contains an example of a blog-style pSEO page, created in WordPress.

4. Landing pages

Creating landing pages using pSEO is a bit difficult, but they can be a super valuable resource if done well. WordPress is not very suitable for creating bulk landing pages, but some other tools or platforms can be used.

Make.com is the best example of programmatic SEO in the style of landing pages, as you can see in the above screenshot. The page is SEO-friendly and has a clear CTA for the users (or, their potential customers).

5. Tools and calculators

Yes, you can even build multiple tools and calculators using the techniques of pSEO as well. Just write the HTML and the JavaScript logic inside the Google Sheets itself or in whatever dataset system you are using.

TheFractionCalculator is a great pSEO example where it’s creating multiple pages with simple calculators and getting more than 80k monthly organic traffic. In fact, this is possible even with WordPress by using the WP All Import plugin.

On a more advanced level, you can take a look at what VEED has been doing by creating 100s of free tools on the concept of engineering as marketing and attracting millions of relevant monthly visitors.

6. Data-focused pages

It requires a complex setup, but if you have a lot of data about something, then you can also create data-focused pages with charts and huge tables by using the technique. If the data doesn’t change very frequently, then it’s a bit easier.

SteamCharts is a good example of data-focused pages where they have separate pages for tracking each Steam game and data is very frequently updated as well.

That’s it.

I hope you get some ideas about the possibilities and what you can do with programmatic SEO. And I’m sure there are tons of other kinds of pages you can build apart from what I mentioned in the list here.

Bulk Convert MPGA Audio Files to MP3

2023-10-22T07:36:39Z

I had over 1,000 audio files in the .mpga format and I wanted to convert them all to .mp3 format. For this, I wrote a Python script that does the conversion with style.

I put all the code inside this GitHub repository.

Now, let’s look at how I converted those 1,000+ files.

1. Put all the .mpga files in a folder

Put all your audio files in a folder and open the VS Code or any other code editor you choose.

2. Create app.py in the same folder

Create the app.py file in the same folder and copy-paste the following code into the file.

import os
import shutil
from pydub import AudioSegment

def convert_mpga_to_mp3(file_path):
    try:
        # Load the .mpga file
        song = AudioSegment.from_file(file_path, "mp3")

        # Convert to mp3 and export
        new_file_path = file_path.rstrip(".mpga") + ".mp3"
        song.export(new_file_path, format="mp3")

        print(f"Converted {file_path} to {new_file_path}")

        return new_file_path
    except Exception as e:
        print(f"Failed to convert {file_path} due to error: {e}")
        return None


# Get all mpga files in the current directory
mpga_files = [f for f in os.listdir('.') if f.endswith('.mpga')]

# Create an 'mp3' directory if it doesn't exist
if not os.path.exists('mp3'):
    os.makedirs('mp3')

# Convert all mpga files
for file_path in mpga_files:
    new_file_path = convert_mpga_to_mp3(file_path)
    if new_file_path is not None:
        # Move the mp3 file to the 'mp3' directory
        try:
            shutil.move(new_file_path, 'mp3/')
            print(f"Moved {new_file_path} to mp3/ directory")
        except Exception as e:
            print(f"Failed to move {new_file_path} due to error: {e}")

3. Run the Python code

Install the pydub library by running the pip install pydub command in the terminal, and now run the Python code by running the following command in the terminal:

python app.py

And as soon as the code runs, converted .mp3 files will start getting saved inside a folder /mp3 in the main folder.

Note that you may need to use pip3 and python3 instead of pip and python, depending upon the Python version and setup your computer has.

That’s it! You can go through this GitHub repo to learn more.

Hope this helps.

How to Disable Cloudflare APO

2023-09-21T21:39:53Z

I had the Cloudflare APO (they call it Automatic Platform Optimization) installed on a website for a few months, it was working all right. But then I enabled ads on the site, and they were not being shown due to APO’s powerful caching.

I was advised to disable the Cloudflare APO thing on my site, and it’s mentioned nowhere how to “completely” disable it. Yes, you can directly uninstall the Cloudflare WordPress plugin, but it still keeps working, as it happened to me and to others.

After spending 3 days finding solutions, I finally know how to completely disable Cloudflare APO from your website. Let me explain, step by step…

1. Prepare the command

First, copy-paste the below command to a plaintext file on your computer, and replace all the variables indicated inside {}.

curl -X PATCH "https://api.cloudflare.com/client/v4/zones/{CF_ZONE_ID}/settings/automatic_platform_optimization" -H "X-Auth-Email: {CF_EMAIL}" -H "X-Auth-Key: {CF_GLOBAL_API_KEY}" -H "Content-Type: application/json" --data '{"value":{"enabled":false}}'

`{CF_ZONE_ID}`

Replace {CF_ZONE_ID} with the Zone ID of the added website in the command that you copied-pasted above.

You can get the Zone ID on the right side when you open a site in Cloudflare, as shown in the above screenshot.

`{CF_EMAIL}`

Replace {CF_EMAIL} with the email that you have used for creating your Cloudflare account.

If you don’t remember, you can find the email after clicking on the profile icon in the top-right corner, as it appears in the above screenshot.

`{CF_GLOBAL_API_KEY}`

Now, replace {CF_GLOBAL_API_KEY} with the Global API Key of your Cloudflare account.

You can get the Global API Key from Profile > API Tokens as shown in the screenshot above. After you click on the View button, you may need to enter your account password in order to see the API key.

Make sure to keep your API key very safe and do not share with anyone else; otherwise, others can get access to your account and make unwanted changes.

Your command is now ready! Let’s move to the next step.

2. Run the command

Open the terminal on your computer, copy-paste the plaintext command in the terminal, and hit enter.

And you should see an output like this in the terminal:

{
  "result": {
    "id": "automatic_platform_optimization",
    "editable": true,
    "value": {
      "cf": false,
      "enabled": false,
      "wordpress": false,
      "wp_plugin": false,
      "hostnames": [
        "yourwebsite.com",
        "www.yourwebsite.com"
      ],
      "cache_by_device_type": false
    },
    "modified_on": null
  },
  "success": true,
  "errors": [],
  "messages": []
}

It means the Cloudflare APO has been successfully disabled for your website. And after it gets disabled, you should also clear all cache by clicking on the Purge Everything button under Caching > Configuration of your site in Cloudflare.

That’s it.

Hope this helps!

FFmpeg is Wild

2023-09-18T19:45:13Z

I recorded a 1:07 long screen record video to showcase how the pSEO keyword ideas database works. While the video could have been directly uploaded to YouTube and Twitter, I wanted to enhance the watchers’ experience a bit by making it a bit faster and adding nice music.

And a single terminal command did all of this; first, watch the video below, and then I’ll show how.

And it all took me just a few seconds.

Cool, right?

Editing videos with FFmpeg

First, you will need to install the FFmpeg tool for your computer and then start with the command. You can get it from their official website.

For the raw video, I had the following requirements:

Make the video a bit faster
Compress the video for social media, and
Add music at a low volume

For this, first, I created a file called fast.sh in the same folder where my raw video your_raw_video.mov and the music audio.mp3 were present. I copy-pasted the following command into the executable file and got the final video your_final_video.mp4 within seconds (not even minutes).

# Extract duration in seconds
duration=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 your_raw_video.mov)

# Calculate new duration after speed up
new_duration=$(bc -l <<< "$duration*0.75")

# Remap audio and video
ffmpeg -i your_raw_video.mov -i audio.mp3 -vcodec libx264 -crf 28 -filter_complex "[0:v]setpts=0.75*PTS[v];[1:a]volume=0.6,atrim=0:$(printf "%.0f" $new_duration)[a]" -map "[v]" -map "[a]" your_final_video.mov

Here’s how you can execute the fast.sh file:

Run chmod +x fast.sh in the terminal in the same folder, and
Run ./fast.sh command in the terminal

And this single terminal command did the following thing to the raw video:

Made the video 1.33x faster
Compressed the video by 92%, and
Added music at 60% volume

The raw screen record video was 1 minute and seconds long and 71.4 MB in file size, and the final video was 50 seconds long and 5.4 MB in file size.

If I had used a video editor tool like iMovie or Adobe Premier Pro, it must have taken me several 5–10 minutes, at least. But FFmpeg did all this in less than 20 seconds.

Now, isn’t that wild?

Never Understood What People Might Want

2023-09-04T03:17:56Z

I have this habit of thinking about what people might be interested in buying and what they would never buy, and I get it wrong all the time. I have rarely anticipated it right.

For example, for more than a year, I have been using a setup of Google Sheets and the OpenAI API to create descriptions and pretty much all different kinds of text content. Over the last few months, several people suggested that I sell the setup to others, but I didn’t consider the idea. And the main reason was that I thought, there are already several extensions and plugins for that, so why would anyone buy a simple script from me?

And that “why” has always deceived me.

After my friend Bikash also suggested making the setup available for others, I thought of giving it a try. I listed the script on Gumroad, created a landing page, launched it on Product Hunt, and then tweeted about it. And to my surprise, tens of people have bought that simple script that I didn’t consider sellable.

What am I doing next?

After failing to see and understand what might people be interested in, I will now try to think less and directly list for sale — I’ll just put another buy button on the internet. And if it works, good, if doesn’t, I will swiftly take it down.

Simple, right?