DEV Community: Prayush Adhikari

MongoDB: Zero to Advanced (The Real Guide Nobody Else Will Write)

Prayush Adhikari — Tue, 24 Feb 2026 08:14:10 +0000

Hey there! So you've heard about MongoDB and now you're wondering what the heck it actually is and why everyone keeps talking about it. I've been down this rabbit hole and I'm going to save you from the confusion, the bad tutorials, and the Stack Overflow rabbit holes.

This is the guide I wish existed when I started.

Let's Talk About Databases First (Bear With Me)

Before we jump into MongoDB, we need to talk about what a database actually is. And no, I'm not going to give you the boring textbook definition.

Think of it this way: you're building a web app. You have users, their profiles, their posts, their comments. Where does all this data live when you close your laptop? Not in your code. Not in RAM. It lives in a database.

A database is just an organized way to store, retrieve, and manage data. That's it. No magic.

Now here's where it gets interesting. There are two main types of databases and understanding the difference is going to save you a LOT of confusion.

SQL vs NoSQL: The Fight That Never Ends

SQL databases (PostgreSQL, MySQL, SQLite) are like super strict spreadsheets. You define the columns upfront, every row must follow the same structure, and everything is neatly organized in tables. Want to change the structure? Hope you like writing migration scripts.

NoSQL databases (MongoDB being the king here) are more like a folder full of documents. Each document can look completely different from the others. Some can have 5 fields, some can have 50. Nobody's going to yell at you.

So when should you use MongoDB? Here's my honest take:

You're building a modern web or mobile app
Your data structure might change a lot (early stage projects)
You need to store nested or complex data (like a user profile with embedded addresses and preferences)
You want to move fast without worrying about schema migrations

When should you NOT use MongoDB? If you're dealing with super complex relationships and need a lot of joins (think banking systems, ERPs), a relational database might serve you better. MongoDB added transactions and lookup operations, but SQL databases still shine there.

Setting Up MongoDB (The Easy Way)

Forget local installation for now. Seriously. The number of people who've given up on MongoDB because of installation headaches is criminal.

We're using MongoDB Atlas — it's free, it's cloud-based, and it's exactly what real companies use in production.

Step 1: Create Your Atlas Account

Head to mongodb.com/products/platform/atlas-database and sign up. It's free. No credit card needed for the free tier.

Step 2: Create Your First Cluster

Once you're in, click "Build a Database" and choose the M0 Free option. Pick whichever cloud provider and region is closest to you. Name your cluster whatever you want — I usually just call it MyCluster.

Step 3: Set Up Access

Atlas will ask you to:

Create a database user (username + password — save these!)
Your current IP address will be added as the part of auto setup process. (If not head to Database and Network access menu from sidebar you will find the way)

Step 4: Get Your Connection String

Click Connect on your cluster → Connect using MongoDB Compass or Connect your application. Copy that connection string. You'll need it later.

Step 5: Install MongoDB Compass

MongoDB Compass is the GUI for MongoDB. It lets you visually browse your data, run queries, and manage collections without writing a single line of code. This is your new best friend.

Download it, install it, paste your connection string, and hit connect. You're in.

Core Concepts: The Building Blocks

Alright, let's get into the actual meat of MongoDB. There are 4 things you need to understand before anything else makes sense.

1. Database

A database in MongoDB is exactly what it sounds like — a container for your data. Think of it like a project folder. If you're building a blog app, you'd probably have a blog database.

2. Collection

A collection is like a table in SQL — except it has no fixed structure. It holds a bunch of documents. In your blog database, you might have a posts collection and a users collection.

3. Document

This is where MongoDB gets cool. A document is a single record — like a row in SQL — but it's stored as JSON-like format called BSON. It looks like this:

{
  "_id": "64f3a1b2c3d4e5f6a7b8c9d0",
  "name": "Prayush Adhikari",
  "email": "prayush@example.com",
  "skills": ["JavaScript", "MongoDB", "Linux"],
  "address": {
    "city": "Kathmandu",
    "country": "Nepal"
  }
}

See that? An array inside a document. An object inside a document. This flexibility is what makes MongoDB powerful.

4. `_id` Field

Every document in MongoDB gets a unique _id field automatically. MongoDB generates it as an ObjectId unless you provide your own. It looks ugly but it's your document's unique fingerprint.

CRUD Operations: The Heart of Everything

CRUD stands for Create, Read, Update, Delete. If you master these four operations, you can build basically anything with MongoDB.

I'll show you both the shell commands (mongosh) and what they look like in Compass so you get the full picture. First create a database and a collection using the gui. I am creating the database named myDatabase and collection named users.

Create: Adding Data

// use the created database
use myDatabase

// Insert a single document
db.users.insertOne({
  name: "Prayush",
  email: "prayush@example.com",
  age: 21,
  joined: new Date()
})

// Insert multiple documents at once
db.users.insertMany([
  { name: "Alice", email: "alice@example.com", age: 25 },
  { name: "Bob", email: "bob@example.com", age: 30 }
])

Read: Finding Data

This is where you'll spend most of your time, so pay attention.

// Find ALL documents in a collection
db.users.find()

// Find documents that match a condition
db.users.find({ age: 21 })

// Find one specific document
db.users.findOne({ email: "prayush@example.com" })

// Find users older than 20
db.users.find({ age: { $gt: 20 } })

// Find users and only return name and email (projection)
db.users.find({}, { name: 1, email: 1, _id: 0 })

// Sort by age ascending
db.users.find().sort({ age: 1 })

// Limit to 5 results
db.users.find().limit(5)

Those $gt, $lt, $gte things are called query operators and they're incredibly powerful. Here's a quick cheat sheet:

Operator	Meaning	Example
`$gt`	Greater than	`{ age: { $gt: 18 } }`
`$lt`	Less than	`{ age: { $lt: 65 } }`
`$gte`	Greater than or equal	`{ age: { $gte: 21 } }`
`$lte`	Less than or equal	`{ score: { $lte: 100 } }`
`$ne`	Not equal	`{ status: { $ne: "banned" } }`
`$in`	In an array of values	`{ role: { $in: ["admin", "mod"] } }`

Update: Changing Data

// Update ONE document
db.users.updateOne(
  { name: "Prayush" },          // Filter: find this document
  { $set: { age: 22 } }         // What to change
)

// Update MULTIPLE documents
db.users.updateMany(
  { age: { $lt: 18 } },
  { $set: { status: "minor" } }
)

// Increment a value
db.users.updateOne(
  { name: "Prayush" },
  { $inc: { loginCount: 1 } }   // Adds 1 to loginCount
)

// Add item to an array
db.users.updateOne(
  { name: "Prayush" },
  { $push: { skills: "Docker" } }
)

The $set, $inc, $push are called update operators. NEVER update a document without using these operators — if you skip them, you'll overwrite the entire document and lose all your data. Ask me how I know.

Delete: Removing Data

// Delete ONE document
db.users.deleteOne({ name: "Bob" })

// Delete MULTIPLE documents
db.users.deleteMany({ age: { $lt: 18 } })

// Delete ALL documents in a collection (use carefully!)
db.users.deleteMany({})

Data Modeling: The Part That Actually Matters

Here's the thing nobody tells beginners — getting your data model right is more important than knowing all the fancy MongoDB features. A bad data model will haunt you for the entire life of your project.

In MongoDB, you have two ways to relate data: embedding and referencing.

Embedding (Nesting Data Inside a Document)

{
  "_id": "user123",
  "name": "Prayush",
  "address": {
    "street": "123 Kathmandu St",
    "city": "Kathmandu",
    "zip": "44600"
  },
  "orders": [
    { "item": "Keyboard", "price": 50 },
    { "item": "Mouse", "price": 25 }
  ]
}

Use embedding when:

The embedded data is always accessed with the parent (you always need the address when you get the user)
The embedded data doesn't change often
The array won't grow unboundedly (don't embed 10,000 comments in a blog post)

Referencing (Like Foreign Keys in SQL)

// users collection
{
  "_id": "user123",
  "name": "Prayush"
}

// posts collection
{
  "_id": "post456",
  "title": "My MongoDB Guide",
  "authorId": "user123"   // References the user
}

Use referencing when:

The data is frequently updated independently
The data is shared across many documents
The array could grow very large

My rule of thumb: embed for read-heavy relationships, reference for write-heavy or large growing relationships.

Intermediate Queries: Leveling Up

Now that you know the basics, let's get into some more powerful queries.

Querying Arrays

// Find users who have "MongoDB" in their skills array
db.users.find({ skills: "MongoDB" })

// Find users who have BOTH "MongoDB" AND "JavaScript"
db.users.find({ skills: { $all: ["MongoDB", "JavaScript"] } })

// Find users where at least one skill matches a condition
db.users.find({ 
  skills: { $elemMatch: { $eq: "Docker" } }
})

Querying Nested/Embedded Documents

Use dot notation to query inside nested objects:

// Find users in Kathmandu
db.users.find({ "address.city": "Kathmandu" })

// Find orders over $100 within user documents
db.users.find({ "orders.price": { $gt: 100 } })

Logical Operators

// AND: find users who are 21 AND from Kathmandu
db.users.find({ 
  $and: [
    { age: 21 },
    { "address.city": "Kathmandu" }
  ]
})

// OR: find users who are admins OR moderators
db.users.find({
  $or: [
    { role: "admin" },
    { role: "moderator" }
  ]
})

// NOT: find users who are NOT banned
db.users.find({ status: { $not: { $eq: "banned" } } })

The Aggregation Framework: Where the Real Magic Happens

This is the part that separates beginners from intermediate developers. The aggregation framework lets you process and transform your data through a pipeline of stages.

Think of it like a factory assembly line — your data goes in one end, gets processed at each stage, and comes out transformed on the other end.

db.orders.aggregate([
  // Stage 1: Filter (like find)
  { $match: { status: "completed" } },

  // Stage 2: Group by category and sum revenue
  { $group: {
    _id: "$category",
    totalRevenue: { $sum: "$price" },
    orderCount: { $sum: 1 }
  }},

  // Stage 3: Sort by revenue descending
  { $sort: { totalRevenue: -1 } },

  // Stage 4: Only return top 5
  { $limit: 5 }
])

This pipeline would give you the top 5 product categories by revenue. Try doing that with just find().

Common Aggregation Stages

Stage	What it does
`$match`	Filter documents (like `find`)
`$group`	Group documents and compute values
`$sort`	Sort results
`$project`	Include/exclude/transform fields
`$limit`	Cap the number of results
`$unwind`	Deconstruct an array into separate documents
`$lookup`	Join with another collection

Real Example: Blog Stats

// Get total posts and average views per author
db.posts.aggregate([
  { $group: {
    _id: "$authorId",
    totalPosts: { $sum: 1 },
    avgViews: { $avg: "$views" },
    totalViews: { $sum: "$views" }
  }},
  { $sort: { totalViews: -1 } }
])

Indexing: Making Your Database Fast

Here's a fact: without indexes, MongoDB scans EVERY document in a collection to find matches. That's fine when you have 100 documents. It's catastrophic when you have 10 million.

An index is like the index at the back of a textbook — instead of reading every page to find "MongoDB," you look at the index, get the page number, and jump straight there.

// Create an index on the email field
db.users.createIndex({ email: 1 })   // 1 = ascending, -1 = descending

// Create a compound index (on multiple fields)
db.users.createIndex({ age: 1, city: 1 })

// Create a unique index (no duplicate emails!)
db.users.createIndex({ email: 1 }, { unique: true })

// Check existing indexes
db.users.getIndexes()

// See how MongoDB executes a query (is it using an index?)
db.users.find({ email: "prayush@example.com" }).explain("executionStats")

When to Add an Index

Add indexes on fields that you:

Query frequently (filters, search)
Sort on often
Use in joins/lookups

Don't add indexes on everything — they take up space and slow down writes. Index what you query. That's the rule.

Transactions: When You Need ACID Guarantees

Here's something that surprises a lot of people: MongoDB supports multi-document transactions since version 4.0. Yes, the same kind of transactions you get in PostgreSQL.

This matters when you need multiple operations to either ALL succeed or ALL fail. Classic example: transferring money between two accounts.

const session = client.startSession();

try {
  session.startTransaction();

  await db.collection('accounts').updateOne(
    { userId: "user1" },
    { $inc: { balance: -100 } },
    { session }
  );

  await db.collection('accounts').updateOne(
    { userId: "user2" },
    { $inc: { balance: 100 } },
    { session }
  );

  await session.commitTransaction();
  console.log("Transfer successful!");

} catch (error) {
  await session.abortTransaction();
  console.log("Transfer failed. Rolled back.");
} finally {
  session.endSession();
}

If the second update fails, the first one is automatically rolled back. No partial transfers. No corrupted data.

Connecting MongoDB to Node.js (Let's Build Something Real)

Theory is cool but let's actually use this thing. Here's how to connect MongoDB to a Node.js app.

Setup

mkdir mongo-demo && cd mongo-demo
npm init -y
npm install mongodb dotenv

Create a .env file:

MONGODB_URI=your_connection_string_from_atlas

Basic Connection

// db.js
const { MongoClient } = require('mongodb');
require('dotenv').config();

let client;

async function connectDB() {
  if (client) return client;

  client = new MongoClient(process.env.MONGODB_URI);
  await client.connect();
  console.log("Connected to MongoDB!");
  return client;
}

module.exports = { connectDB };

Building a Simple CRUD API

// app.js
const { connectDB } = require('./db');

async function main() {
  const client = await connectDB();
  const db = client.db("blogDB");
  const posts = db.collection("posts");

  // CREATE
  const newPost = await posts.insertOne({
    title: "My First Post",
    content: "MongoDB is actually pretty cool",
    author: "Prayush",
    views: 0,
    tags: ["mongodb", "tutorial"],
    createdAt: new Date()
  });
  console.log("Created:", newPost.insertedId);

  // READ
  const allPosts = await posts.find({ author: "Prayush" }).toArray();
  console.log("Posts:", allPosts);

  // UPDATE
  await posts.updateOne(
    { _id: newPost.insertedId },
    { $inc: { views: 1 } }
  );

  // DELETE
  // await posts.deleteOne({ _id: newPost.insertedId });

  await client.close();
}

main();

Mongoose: The Better Way to Use MongoDB with Node.js

If you're building a real app with Node.js, you'll want to use Mongoose instead of the raw MongoDB driver. Mongoose adds schema validation, middleware, and a bunch of quality-of-life features.

npm install mongoose

const mongoose = require('mongoose');

// Define a schema
const postSchema = new mongoose.Schema({
  title: { type: String, required: true },
  content: { type: String, required: true },
  author: { type: String, required: true },
  views: { type: Number, default: 0 },
  tags: [String],
  createdAt: { type: Date, default: Date.now }
});

// Create a model
const Post = mongoose.model('Post', postSchema);

// Connect and use
async function run() {
  await mongoose.connect(process.env.MONGODB_URI);

  // Create
  const post = new Post({
    title: "Mongoose is Great",
    content: "Schema validation saves lives",
    author: "Prayush"
  });
  await post.save();

  // Find
  const posts = await Post.find({ author: "Prayush" }).sort({ createdAt: -1 });
  console.log(posts);

  await mongoose.disconnect();
}

run();

The big win with Mongoose? If you try to save a document without a required field, it throws an error before it even hits the database. That's validation at the schema level.

Atlas Search and Vector Search: The 2025-2026 Stuff

This is where MongoDB gets genuinely exciting for modern applications.

Atlas Search

Built on Apache Lucene, Atlas Search lets you add full-text search to your app without spinning up a separate Elasticsearch instance.

// Full-text search on posts
db.posts.aggregate([
  {
    $search: {
      index: "default",
      text: {
        query: "mongodb tutorial",
        path: ["title", "content"]
      }
    }
  },
  { $limit: 10 }
])

Vector Search (For AI Apps)

If you're building RAG applications or any AI-powered feature that needs semantic search, MongoDB Atlas Vector Search is a game changer. You store embeddings (vectors from AI models) right alongside your data and query by similarity.

// Search for semantically similar documents
db.articles.aggregate([
  {
    $vectorSearch: {
      index: "vector_index",
      path: "embedding",
      queryVector: [0.1, 0.25, -0.3, ...],  // Your query embedding
      numCandidates: 100,
      limit: 10
    }
  }
])

This is the technology that powers modern AI chatbots that can "remember" things from documents. MongoDB lets you build this without stitching together 5 different services.

Time Series Collections (MongoDB 8.x)

Got IoT data? Logs? Metrics? MongoDB 8.x introduced optimized time series collections that store time-based data WAY more efficiently than regular collections.

// Create a time series collection
db.createCollection("sensorData", {
  timeseries: {
    timeField: "timestamp",
    metaField: "sensorId",
    granularity: "seconds"
  }
})

// Insert time series data
db.sensorData.insertMany([
  { timestamp: new Date(), sensorId: "sensor1", temperature: 23.5, humidity: 60 },
  { timestamp: new Date(), sensorId: "sensor2", temperature: 25.1, humidity: 55 }
])

MongoDB automatically handles compression and optimized storage for you. This stuff used to require specialized databases like InfluxDB. Now MongoDB handles it natively.

The Real Secret to MongoDB Mastery

Here's what nobody tells you: knowing all the commands is the easy part. The hard part is knowing which tool to reach for.

Every concept I've covered comes down to one question: what is the most efficient way to store and retrieve THIS specific data for THIS specific use case?

Embedding vs referencing is a design decision, not a rule.
Indexes are solutions to performance problems, not defaults you add to everything.
Aggregations are for analytics and transformations, not for basic reads.
Transactions are for when correctness absolutely cannot be compromised.

Start building something. A blog. A todo app. A movie tracker. Break it. Fix it. Look at your slow queries. Add indexes. Refactor your data model when it starts hurting. That's how you actually learn MongoDB.

What's Next?

Here are some things I'd cover in separate deep dives if you want me to:

Full REST API with Express + MongoDB — Let's build it properly
Authentication system with MongoDB — JWT, sessions, the whole thing
Sharding and scaling — When your app hits a million users
MongoDB Change Streams — Real-time notifications without polling
Atlas Triggers and Functions — Serverless functions that react to database events

Drop a comment with which one you want first and I'll get to it.

Let's Connect

I'm Prayush Adhikari, grinding through computer engineering and writing content that actually helps. If this guide saved you from a bad tutorial or a confusing Stack Overflow thread, we're even.

LinkedIn: adhikareeprayush
GitHub: adhikareeprayush

What do you want me to cover next? Drop it in the comments.

Now go build something with MongoDB.

Database Indexing Explained Like You're 5 (Then Like You're a Senior Dev)

Prayush Adhikari — Wed, 12 Nov 2025 19:51:22 +0000

Hey there! So you want to understand database indexing? Cool. Let me break this down in a way that actually makes sense, starting from the absolute basics and working our way up to the stuff that'll make you look like a genius in your next code review.

The 5-Year-Old Explanation

Imagine you have a massive book with 10,000 pages about different animals. No table of contents, no organization, just random animals on random pages.

Now, your teacher asks: "Find me information about elephants."

What do you do? You flip through every single page until you find elephants. Page 1, nope. Page 2, nope. Page 3, nope... this is going to take forever, right?

That's your database without indexes.

Now imagine the same book, but at the front, there's a special page that says:

Elephants: Page 4,521
Lions: Page 892
Penguins: Page 7,234

Boom. You jump straight to page 4,521. Found it in seconds.

That's an index.

Simple, right? Now let's get into the real stuff.

The Real World Problem

Let's say you're building an app. Could be anything, a blog, an e-commerce site, whatever. You've got a users table with 1 million records. Someone tries to log in, and you run this query:

SELECT * FROM users WHERE email = 'prayush@example.com';

Without an index, your database does what's called a full table scan. It literally checks every single one of those 1 million rows. Every. Single. One.

On my machine, that query took 2.3 seconds without an index.

With an index? 0.003 seconds.

Yeah, you read that right. From 2.3 seconds to 3 milliseconds. That's not just fast, that's "your users don't rage-quit your app" fast.

How Indexes Actually Work (Getting Technical)

Alright, now we're getting into the good stuff. Let's talk about what's really happening under the hood.

The B-Tree Structure

Most databases use something called a B-Tree (Balanced Tree) for indexes. And no, despite what everyone thinks, the B doesn't stand for "binary." It actually stands for "balanced" or possibly "Bayer" (the guy who invented it).

Here's the deal: a B-Tree organizes your data in a tree structure where:

The root node contains pointers to other nodes
Intermediate nodes contain more pointers
Leaf nodes contain the actual data (or pointers to the actual data)

When you search for something, the database traverses this tree. Instead of checking 1 million rows, it might only need to check 3-4 nodes to find what it's looking for.

Let me show you what I mean with a real example from a project I worked on:

-- Creating a simple users table
CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255),
    username VARCHAR(100),
    created_at TIMESTAMP
);

-- Insert a million records (not showing the full script here, trust me)
-- Now let's see the difference

Without index:

EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'random@email.com';
-- Seq Scan on users (cost=0.00..25833.00 rows=1 width=89) (actual time=2347.921..2347.922 rows=1 loops=1)

With index:

CREATE INDEX idx_users_email ON users(email);

EXPLAIN ANALYZE SELECT * FROM users WHERE email = 'random@email.com';
-- Index Scan using idx_users_email on users (cost=0.42..8.44 rows=1 width=89) (actual time=0.038..0.039 rows=1 loops=1)

The numbers don't lie. The cost dropped from 25833 to 8.44. That's massive.

Types of Indexes (Because One Size Doesn't Fit All)

1. Single Column Index

The basic one we've been talking about:

CREATE INDEX idx_email ON users(email);

Use this when you're frequently searching by a single column.

2. Composite Index

Multiple columns in one index:

CREATE INDEX idx_email_username ON users(email, username);

Here's where it gets interesting. The order matters. This index is great for:

SELECT * FROM users WHERE email = 'x' AND username = 'y'; -- Fast
SELECT * FROM users WHERE email = 'x'; -- Also fast
SELECT * FROM users WHERE username = 'y'; -- Slow! Doesn't use the index

Why? Because the index is organized by email first, then username. It's like a phone book sorted by last name, then first name. You can't efficiently find someone by just their first name.

3. Unique Index

Enforces uniqueness AND speeds up queries:

CREATE UNIQUE INDEX idx_unique_email ON users(email);

Perfect for emails, usernames, or anything that should be unique.

4. Partial Index

This one's cool. Index only part of your data:

CREATE INDEX idx_active_users ON users(email) WHERE is_active = true;

If you only ever query active users, why index the inactive ones? Save space, save time.

5. Full-Text Index

For searching text content:

CREATE INDEX idx_post_content ON posts USING GIN(to_tsvector('english', content));

This is what makes your blog search actually work. I use this on my own projects and it's a game changer for search functionality.

The Dark Side: When Indexes Hurt You

Here's what nobody tells beginners: indexes aren't free. They come with a cost.

Storage Cost

Every index is basically a copy of your data in a different structure. More indexes = more disk space. I learned this the hard way when my database size doubled because I got index-happy.

Write Performance

Every time you INSERT, UPDATE, or DELETE, the database has to update all your indexes too.

Real talk: I once had a table with 12 indexes. Inserts were taking forever. Dropped it down to 4 strategic indexes, and suddenly my batch inserts went from 5 minutes to 30 seconds.

The Wrong Index Is Worse Than No Index

True story: I once created an index on a column with only 3 possible values (status: pending, active, inactive). The database was spending more time maintaining and reading the index than it would have just scanning the table.

Rule of thumb: If a column has low cardinality (not many unique values), skip the index.

Common Indexing Mistakes (Learn from My Pain)

Mistake 1: Indexing Everything

I did this. You'll probably do this too. Don't.

The Fix: Index based on your actual queries. Use EXPLAIN ANALYZE to see what's slow, then index specifically for that.

Mistake 2: Ignoring Index Order in Composite Indexes

Remember that email + username example? Put the most selective column first.

-- Bad: username has duplicates, email is unique
CREATE INDEX idx_bad ON users(username, email);

-- Good: email is unique, username has duplicates  
CREATE INDEX idx_good ON users(email, username);

Mistake 3: Not Analyzing Your Indexes

Indexes can get bloated over time. In PostgreSQL:

REINDEX TABLE users;

I do this monthly on my production databases. Keeps things running smooth.

Mistake 4: Forgetting About Covering Indexes

If your query only needs data that's in the index, the database doesn't even need to touch the main table.

CREATE INDEX idx_covering ON users(email, username, created_at);

-- This query only touches the index, super fast
SELECT email, username FROM users WHERE email = 'x';

Mistake 5: Over-Optimizing Too Early

I wasted weeks optimizing queries that ran once a day on 1000 rows. Focus on what matters: frequent queries on large tables.

Advanced Strategies (Senior Dev Territory)

Strategy 1: Index-Only Scans

Structure your indexes so queries can be answered without touching the table:

CREATE INDEX idx_posts_covering ON posts(user_id, created_at, title);

-- This query is lightning fast
SELECT title, created_at FROM posts WHERE user_id = 123 ORDER BY created_at DESC;

Strategy 2: Conditional Indexes with Expressions

You can index the result of a function:

CREATE INDEX idx_lower_email ON users(LOWER(email));

-- Now this is fast
SELECT * FROM users WHERE LOWER(email) = 'prayush@example.com';

Strategy 3: Index Hints (Use Sparingly)

Sometimes the query planner gets it wrong. In MySQL:

SELECT * FROM users USE INDEX (idx_email) WHERE email = 'x';

But honestly, if you need hints, you probably need better indexes.

Strategy 4: Monitoring Index Usage

Find unused indexes and kill them:

-- PostgreSQL
SELECT schemaname, tablename, indexname, idx_scan
FROM pg_stat_user_indexes
WHERE idx_scan = 0;

I do this every month. Found 15 unused indexes once. Dropped them all, freed up 2GB of space.

Real-World Example: My Blog Optimization

Let me show you something from an actual project. I have a blog posts table:

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id INTEGER,
    title VARCHAR(255),
    content TEXT,
    status VARCHAR(20),
    created_at TIMESTAMP,
    updated_at TIMESTAMP
);

Initial problem: Homepage query was taking 800ms to load recent posts.

SELECT * FROM posts 
WHERE status = 'published' 
ORDER BY created_at DESC 
LIMIT 10;

My indexing solution:

-- Partial index for published posts only
CREATE INDEX idx_published_posts ON posts(created_at DESC) 
WHERE status = 'published';

-- For author pages
CREATE INDEX idx_author_posts ON posts(user_id, created_at DESC)
WHERE status = 'published';

-- For full-text search
CREATE INDEX idx_post_search ON posts 
USING GIN(to_tsvector('english', title || ' ' || content));

Results:

Homepage: 800ms → 12ms
Author pages: 450ms → 8ms
Search: Actually works now (was timing out before)

Three strategic indexes. Not twelve random ones. That's the key.

The Practical Checklist

Here's what I do for every new table:

Primary key gets an index automatically (don't create one manually)
Foreign keys ALWAYS get indexed

   CREATE INDEX idx_posts_user_id ON posts(user_id);

Columns in WHERE clauses get indexed (if the query runs often)
Columns in ORDER BY get indexed (especially with LIMIT)
Run EXPLAIN ANALYZE on slow queries before creating indexes
Monitor index usage monthly and drop the dead ones

Tools I Actually Use

pgAdmin

For PostgreSQL, pgAdmin's query analyzer is solid. Shows you exactly what's happening.

MySQL Workbench

Same thing for MySQL. The visual EXPLAIN is chef's kiss.

Database Monitoring

I run a self-hosted Grafana dashboard that tracks:

Query execution times
Index usage stats
Table scan counts
Cache hit ratios

Want a tutorial on setting this up? Let me know because monitoring is half the battle.

The Bottom Line

Indexing isn't rocket science, but it's not something you can just wing either. Here's the real strategy:

Start without indexes (except primary keys and foreign keys)
Build your app, collect real usage data
Find the slow queries (EXPLAIN ANALYZE is your friend)
Add indexes strategically
Monitor and adjust
Don't over-optimize early

And remember: the best index is the one that solves a real performance problem. Not the one that looks cool in your schema.

Let's Connect

I'm Prayush Adhikari, grinding through computer engineering and breaking down complex topics into actually useful content. If database performance gets you excited (or frustrated), you're in the right place.

Got questions? Want me to cover something specific about databases? Drop a comment. I read every single one.

LinkedIn: adhikareeprayush
Twitter: codersburnout
GitHub: adhikareeprayush

Next up, I'm thinking about diving into database sharding or maybe query optimization techniques. What would you rather read about? Let me know.

Now go index something. But not everything.

Setting Up Your Command Line Assistant with Google Services (The Complete Guide)

Prayush Adhikari — Tue, 04 Nov 2025 07:27:06 +0000

Hey there! Welcome back. It's been a minute since my last blog on 7 Productivity Hacks That Changed My Life. Remember hack number 3? The wild command line assistant that manages your entire Google workspace from the terminal?

Yeah, that one blew up in the comments. Everyone wanted the full breakdown. So here it is, the complete no-BS guide to setting up your own command line assistant with access to Gmail, Google Drive, Calendar, and basically your entire Google ecosystem.

Why This Setup is Absolutely Insane

Before we dive in, let me paint you a picture of what your life looks like once this is running:

Send emails without ever opening a browser
Schedule meetings with a single command
Upload files to Drive from your terminal
Search your Gmail like you're querying a database
Manage calendar events faster than you can say "productivity"

And the best part? It's all happening in your terminal. No clicking. No switching windows. Just pure, efficient command-line magic.

What You'll Need (The Boring But Necessary Stuff)

Look, I'm not gonna sugarcoat it. You need:

A computer (obviously)
Stable internet connection (wild requirement in 2024, I know)
Basic familiarity with terminal/command line
A Google account
About 30-45 minutes to set this up properly

One-time setup, lifetime benefits. Let's go.

Step 1: Install Gemini CLI (And Why Version Matters)

Here's where most people mess up. You can't just install the latest version and call it a day.

Why Gemini CLI?

Simple. It integrates seamlessly with Google Apps Script, giving us a robust MCP (Model Context Protocol) server for our command line agent. The integration is chef's kiss level smooth.

The Version Trap:

I spent hours debugging before I figured this out. You MUST use version 0.1.12. The latest versions? Broken. Buggy. Frustrating.

Save yourself the headache and install the specific version:

npm install -g @google/generative-ai-cli@0.1.12

Verify it installed correctly:

gemini --version

You should see 0.1.12. If not, uninstall and try again.

Step 2: Set Up Google Cloud Console (The Foundation)

This is crucial. Don't skip this step or you'll run into permission issues later.

Create Your Project:

Head over to Google Cloud Console
Click "New Project" in the top dropdown
Name it something memorable (I called mine "CLI-Assistant")
Click Create

Enable the APIs:

You need to enable these APIs for your project:

Go to "APIs & Services" > "Library"
Search and enable each of these:
- Gmail API
- Google Drive API
- Google Calendar API
- Google Docs API (optional but recommended)
- Google Sheets API (optional but recommended)

Generate Your Gemini API Key:

In the Cloud Console, go to "APIs & Services" > "Credentials"
Click "Create Credentials" > "API Key"
Copy this key somewhere safe (you'll need it multiple times)
(Optional but recommended) Click "Restrict Key" and limit it to only the APIs you enabled

Pro tip: Keep this key private. Like, seriously private.

Step 3: Create Your Google Apps Script

Time to build the brain of the operation.

Set Up the Project:

Go to script.google.com
Click "New Project"
Name it something like "MCP Server for CLI"

Write the Code.gs File:

Delete the default code and paste this:

const apiKey = "YOUR_GEMINI_API_KEY_HERE";

const doPost = (e) => main(e);

function main(eventObject) {
  const m = ToolsForMCPServer;
  m.apiKey = apiKey;

  // Enable the tools you want to use
  // Play around with these flags
  m.enableBaseTools = true;
  m.enableClassroomTools = false;
  m.enablePeopleTools = false;
  m.enableAnalyticsTools = false;
  m.enableMapsTools = false;

  const object = { eventObject, items: m.getServer() };
  return new MCPApp.mcpApp({ accessKey: "sample" })
    .setServices({ lock: LockService.getScriptLock() })
    .server(object);
}

Replace YOUR_GEMINI_API_KEY_HERE with the API key you generated earlier.

About those flags:

enableBaseTools: This is the core. Gmail, Drive, Calendar. Keep this true.
The others are specialized. Enable them if you need Classroom, Analytics, or Maps integration.

Create the appsscript.json File:

This is where permissions live. It's critical.

In your Apps Script project, click "Project Settings" (gear icon)
Check "Show 'appsscript.json' manifest file in editor"
Go back to the editor, you'll see appsscript.json appear
Replace its contents with this:

{
  "timeZone": "YOUR_TIMEZONE_HERE",  // e.g., America/Los_Angeles
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "dependencies": {
    "enabledAdvancedServices": [
      {
        "userSymbol": "Drive",
        "serviceId": "drive",
        "version": "v3"
      },
      {
        "userSymbol": "Gmail",
        "version": "v1",
        "serviceId": "gmail"
      },
      {
        "userSymbol": "Calendar",
        "version": "v3",
        "serviceId": "calendar"
      }
    ],
    "libraries": [
      {
        "userSymbol": "MCPApp",
        "libraryId": "1TlX_L9COAriBlAYvrMLiRFQ5WVf1n0jChB6zHamq2TNwuSbVlI5sBUzh",
        "version": "18"
      },
      {
        "userSymbol": "ToolsForMCPServer",
        "libraryId": "1lnE7UL1jQgPDbTB9yjhiwZM0SaS9MObhzvWUWb_t8FisO6A3bLepvM2j",
        "version": "39"
      }
    ]
  },
  "webapp": {
    "executeAs": "USER_DEPLOYING",
    "access": "ANYONE_ANONYMOUS"
  },
  "oauthScopes": [
    "https://www.googleapis.com/auth/gmail.modify",
    "https://www.googleapis.com/auth/gmail.send",
    "https://www.googleapis.com/auth/drive",
    "https://www.googleapis.com/auth/drive.file",
    "https://www.googleapis.com/auth/calendar",
    "https://www.googleapis.com/auth/calendar.events",
    "https://www.googleapis.com/auth/spreadsheets",
    "https://www.googleapis.com/auth/documents",
    "https://www.googleapis.com/auth/presentations",
    "https://www.googleapis.com/auth/forms",
    "https://www.googleapis.com/auth/script.external_request"
  ]
}

Important notes:

Change timeZone to your timezone
The oauthScopes are the permissions. This setup requests access to Gmail, Drive, Calendar, Docs, Sheets, etc.
The libraries (MCPApp and ToolsForMCPServer) are essential. Don't change these IDs.

Save everything (Ctrl+S or Cmd+S).

Step 4: Deploy Your Script

This is where your code becomes accessible.

In Apps Script, click "Deploy" > "New deployment"
Click the gear icon next to "Select type"
Choose "Web app"
Fill in the details:
- Description: "MCP Server v1" (or whatever you want)
- Execute as: "Me"
- Who has access: "Anyone"
Click "Deploy"
Authorize the app (Google will ask you to review permissions)
- Click "Review Permissions"
- Choose your Google account
- Click "Advanced" (if it says the app is unverified)
- Click "Go to your project name"
- Click "Allow"
Copy the Web App URL that appears. It looks like: https://script.google.com/macros/s/SOME_LONG_ID/exec

Keep this URL handy. You're almost there.

Step 5: Configure Gemini CLI to Use Your MCP Server

Now we connect everything together.

Initialize Gemini CLI:

Open your terminal and run:

gemini config

Follow the prompts to set up your Gemini API key if you haven't already.

Add the MCP Server:

Run:

gemini

Once Gemini CLI starts, type:

/mcp

This opens the MCP configuration menu. Follow the interactive prompts:

Choose "Add new MCP server"
Enter a name: google-services (or whatever you prefer)
Paste your Web App URL from Step 4
Confirm the configuration

Test the Connection:

Try a simple command:

Check my latest emails

Or:

What's on my calendar today?

If it works, you'll see Gemini accessing your Google services and returning results. If not, double-check:

Your API key is correct in Code.gs
The Web App URL is correct
You authorized the script properly

Step 6: Start Living in the Future

You're done. Seriously. Now you can:

Send Emails:

Send an email to john@example.com with subject "Meeting Tomorrow" and body "Hey John, are we still on for 3pm?"

Schedule Meetings:

Create a calendar event for tomorrow at 2pm titled "Team Standup"

Search Gmail:

Find all emails from boss@company.com from last week

Upload to Drive:

Upload document.pdf to my Google Drive

And So Much More

The possibilities are endless. The more you use it, the more you'll discover what's possible.

Pro Tips and Troubleshooting

Common Issues:

"Permission denied" errors:

Go back to your Apps Script and re-deploy with fresh permissions
Make sure all APIs are enabled in Google Cloud Console

"Version mismatch" errors:

Confirm you're using gemini-cli version 0.1.12
Uninstall and reinstall if needed: npm uninstall -g @google/generative-ai-cli && npm install -g @google/generative-ai-cli@0.1.12

MCP server not responding:

Check your Web App URL is correct
Make sure the deployment is set to "Anyone" access
Verify your API key is valid

Make It Better:

Customize the flags in Code.gs based on what you actually use
Add more oauth scopes if you need access to other Google services
Create aliases in your shell for common commands
Experiment with different prompts to see what works best

The Real Impact

Here's what changed for me after setting this up:

I send emails 5x faster
Scheduling meetings takes seconds instead of minutes
I never lose track of files because I can search Drive from anywhere
My workflow is completely keyboard-driven (no more mouse clicking through UIs)

It's not just about speed. It's about staying in flow. When you can do everything from the terminal, you're not context-switching. Your brain stays focused. That's the real productivity boost.

What's Next?

Want me to dive deeper into:

Custom automation workflows with this setup?
Advanced MCP server configurations?
Integrating other services beyond Google?

Drop a comment and let me know what you want to see next.

Let's Connect

I'm Prayush Adhikari, computer engineering student and productivity nerd. I'm documenting my journey of building systems that actually work.

If this guide helped you (or if you got stuck somewhere), let's connect:

LinkedIn: adhikareeprayush
Twitter: codersburnout
GitHub: adhikareeprayush

Drop a comment below with:

Which part of the setup you found most useful
What you're automating first
What guide you want next

Thanks for reading! Now go build something that makes your life easier.

P.S. If you're stuck on any step, drop a comment. I read and respond to everything.

7 Productivity Hacks That Changed My Life (And Will Change Yours Too)

Prayush Adhikari — Wed, 15 Oct 2025 08:19:43 +0000

Hey there! I am glad you ended up here. Look, I've tried every productivity hack under the sun, and most of them? Complete garbage. But the ones I'm about to share? These actually work. And I'm using them right now as I write this.

Let's Talk About Productivity (The Real Deal)

I like to be productive and who doesn't? But wtf is productivity in the first place?

Here's the thing most people get wrong: productivity isn't about grinding 16 hours a day or having 47 tabs open while pretending to multitask. It's about doing things more efficiently or better yet, doing repetitive things more efficiently.

And no, efficiency isn't just speed. It's about finding the best approach to get the best possible result. Sometimes that means slowing down to automate something that'll save you hours later.

Since we have gone through some of the basics, lets dive into the actual hacks that have transformed how I work.

The Hacks That Actually Matter

1. Ditch Chrome, Seriously

One of the unavoidable things in our life is a web browser. We're constantly living in our browsers when we're online. I have tried almost all the web browsers out there and have finally settled on one that doesn't make me want to throw my laptop out the window.

Enter Vivaldi.

Yeah yeah, it eats 2-3gb of RAM like it's nothing, but hear me out. If your computer has 16gb+ RAM or you're already using Chrome (which is basically a RAM black hole), you need to try this.

Why Vivaldi slaps:

It's chromium based so all your favorite extensions work
Mouse gestures that make you feel like a wizard
Keyboard shortcuts for literally everything
Multiple workspaces to keep your 600 tabs organized
Themes that don't look like they're from 2010
Zero bugs in my experience (and I push software to its limits)

The customization is insane. You can make it look and work exactly how your brain operates. And that's the key to productivity, working with tools that match your workflow, not against it.

2. Automate Your Social Media Like a Boss

Social medias like Discord and Telegram are goldmines for automation. And no, you don't need to be a coding wizard to make this happen.

I've been running self-hosted n8n on my VPS and it's changed the game. Here's what I've built:

Stream Suggester - Because decision fatigue is real
Gemini in Telegram - My AI buddy on the go
Techy - Sends me tech news from multiple RSS feeds automatically

The best part? You set it up once and forget about it. While everyone else is manually checking feeds and posting updates, you're three steps ahead.

Want me to drop a full tutorial on setting up n8n locally or on a VPS? Drop a comment and let me know because this deserves its own deep dive.

3. Command Line Assistant (This One's Wild)

Alright, here the things go pure wild. I have a command line assistant that basically runs my digital life. I'm talking:

Creating Google meetings with a single command
Adding calendar events instantly
Scanning my Gmail for important stuff
Sending emails without opening a browser
Managing all Google services from the terminal

This setup is chef's kiss level productivity. Here's the quick rundown:

The Setup (Simplified):

Install gemini-cli (the MCP server integration is smooth)
Create a Google Apps Script (hit me up if you want my exact script)
Configure Google Cloud Console permissions
Grab your Gemini API key
Authorize and boom, you're living in the future

This needs its own blog because the full process is meaty, but trust me, once you have this running, you'll feel like Tony Stark.

4. Your IDE Matters More Than You Think

Hot take: Your code editor can make or break your productivity.

I use Neovim and yes, I know what you're thinking. "Oh great, another Neovim evangelist." But hear me out.

I felt the exact same way when people recommended it to me. Thought they were just trying to be elitist. But after customizing it with the right plugins, I'm never going back.

Real talk though: Don't just jump into Neovim cold turkey. Use VS Code AND Neovim side by side at first. Slowly transition when you're comfortable. The learning curve is real, but the productivity gains are worth it.

Want a Neovim setup tutorial? Let me know and I'll break down my entire config.

5. Build Your Second Brain

Obsidian has changed how I think.

No, seriously. Having all your knowledge in one searchable, linked system is like having superpowers. And the best part? It's completely free if you set up sync yourself (I wrote a whole blog about this).

Why Obsidian wins:

Massive community plugins
Works on all devices
Free sync if you're smart about it
Everything is markdown (lightweight and future-proof)
Themes that don't hurt your eyes
Integration with everything

Your brain isn't meant to remember everything. It's meant to make connections. Let Obsidian handle the storage, you handle the thinking.

6. Your Terminal Shouldn't Suck

One of the biggest headaches was my terminal. I wanted it to look cool, suggest past commands, and generally not feel like I time-traveled to 1995.

Solution? Zsh with oh-my-zsh.

The productivity boost is subtle but massive. Auto-suggestions, better history, plugins for days, and honestly, when your terminal looks good, you want to use it more. And the more comfortable you are in the terminal, the more powerful you become.

It has surely helped me become more productive without even realizing how much I've improved at command line.

7. Make The Switch to Linux (Yes, Really)

I would highly recommend all of you to switch to Linux on your personal computers. And no, I'm not one of those "I use Arch btw" people (okay maybe a little).

Here's why Windows is holding you back:

Less secure by design
Bloated with stuff you'll never use
Ads in the START MENU (seriously Microsoft?)
Limited customization
Constant forced updates at the worst times
You don't actually own your OS

Linux gives you:

Complete control
No bloat
Better security
Customization freedom
Better performance
Actually free (as in freedom)

Need help choosing a distro? Want a full guide on making the switch? Drop a comment. I can write a whole series on this.

The Real Secret

Here's what nobody tells you about productivity: it's not about the tools. It's about designing systems that work FOR you, not against you.

Every hack I've shared comes down to one thing: removing friction. The less mental energy you spend on repetitive tasks, the more you have for what actually matters.

So start with one hack. Just one. Get it working. Then move to the next. Don't try to overhaul your entire workflow overnight because that's how you end up productive for exactly two days before burning out.

Let's Connect

I'm Prayush Adhikari, currently grinding through computer engineering and building my online presence one blog at a time. I'm bringing more content like tutorials, deep dives, and honest takes on tech.

If this helped you (or if you think I'm completely wrong about something), let's connect:

Drop a comment below with which hack you're trying first
Follow me for more content that actually helps
Share this if you know someone stuck in productivity hell

Connect with me:

Linkedin: adhikareeprayush
Twitter: codersburnout
Github: adhikareeprayush

What productivity hack should I cover next? Let me know in the comments.

Thanks for reading! Now go automate something.

Stop Paying for Obsidian Sync: Here's How I Actually Did It

Prayush Adhikari — Mon, 06 Oct 2025 19:26:04 +0000

So you've fallen into the Obsidian rabbit hole. Good. Now you're realizing that having your notes on just one device is annoying as hell, and Obsidian wants $10/month to fix that problem.

I get it—the devs deserve support, they built something genuinely useful. But I'm also not about to pay a subscription for syncing text files. Yes, I said it. That's all your vault is. A bunch of .md files sitting in a folder.

So I rolled my own sync setup with Syncthing-Fork, and it's been running flawlessly across my laptop, phone, and a VPS for months. Zero cost, zero drama. Let me show you how.

The Beauty of Obsidian: It's Just Files

Here's why this works at all: Obsidian doesn't trap your data in some proprietary hellscape. Your vault is literally just a folder on your filesystem. Open it. Look at it. Those are markdown files. You could edit them in Notepad if you wanted to punish yourself.

This isn't revolutionary—it's how software should work. But in 2025, when every app wants to be a SaaS product with your data held hostage on their servers, Obsidian's approach feels almost rebellious.

No database. No API calls to authenticate your right to access your own thoughts. Just files and folders, like it's 1995 and we still believed in owning our data.

Which means if you can sync a folder, you can sync your entire Obsidian vault. And you absolutely can sync a folder without giving someone money every month.

Syncthing-Fork: The Unsexy Solution That Actually Works

Syncthing is that rare piece of software that does one thing, does it well, and doesn't try to upsell you on AI features or premium tiers. It's open source, peer-to-peer, and once you set it up, you genuinely forget it exists.

Syncthing-Fork is the Android variant that actually gets maintained.

What sold me: I edit a note on my phone at 2 AM because my brain won't shut up. By the time I walk to my desk in the morning, that note is already on my laptop. No sync button. No "waiting for upload." It just is.

The whole thing runs device-to-device. Encrypted. No cloud middleman harvesting your data to train their next AI model.

My Setup: Three Devices Playing Nice

I'm running this across:

Laptop (Arch BTW)
Android phone (Syncthing-Fork from Nickola Hristov)
VPS (Docker container, always online)

The VPS is technically optional. But here's the thing: if my laptop's off and I change something on my phone, the VPS catches it immediately. Then when my laptop wakes up, it syncs from the VPS. It's basically a relay that ensures changes never get stuck in limbo. I am also planning to use static site generator out of .md files for future so it will be helpful ig.

Plus it's an automatic off-site backup. My laptop could spontaneously combust and my vault's still sitting on that VPS.

How I Actually Set This Up

Making Syncthing Run Without Thinking About It

Laptop: Installed Syncthing, made it a systemd service so it starts on boot. I never want to manually start this thing. If I have to remember to run it, I'll forget, and then I'll have sync conflicts. Automate or die.

VPS: Spun up a Docker container. Wrote a basic docker-compose.yml, ran it, forgot about it. Docker handles restarts, keeps it isolated, makes updates trivial. The VPS isn't doing anything else demanding—it's just sitting there being reliable, which is what servers are actually for.

Phone: Installed Syncthing-Fork, gave it the permissions it was crying about, set it to auto-start. Battery impact is negligible. We're syncing text, not mining crypto.

The Connection Dance

Every Syncthing instance has a device ID. I added all three devices to each other. Think of it like exchanging SSH keys, except it's actually user-friendly.

Then I pointed Syncthing at my Obsidian vault folder and told it to share that folder with all my devices. That's it. That's the setup.

Watching It Actually Work

Change a file on any device. Syncthing detects it within seconds. The change propagates to the other devices. Obsidian notices the file changed and updates its view.

It's not magic—it's just file watching and network sockets. But it feels magic when you're used to cloud sync services that randomly decide they need five minutes to "think about it."

Why Syncthing Doesn't Suck

Block-level syncing means it only transfers what changed. Edit one paragraph? It sends that delta, not the entire file. This matters when you're on mobile data or have a 50MB vault full of images.

Conflict handling is reasonable. If you somehow edit the same file on two disconnected devices (how?), it creates a conflict copy instead of randomly picking a winner. You manually merge. Annoying, but better than silent data loss.

Everything's encrypted in transit. Your existential crisis notes aren't flying across the internet in plaintext for your ISP to judge.

The VPS Piece

Two devices can sync directly without a VPS. Phone talks to laptop when both are online. But the VPS makes this bulletproof.

I'm paranoid about losing data. Having an always-online third node means changes always have somewhere to go. Plus, it's offsite. My apartment could burn down and my notes would survive.

Running in Docker is just good practice. Isolated, reproducible, updateable. One docker-compose up -d and it's running forever.

What This Actually Feels Like

I've been running this for months. I don't think about it. That's the highest compliment I can give any infrastructure.

I dump thoughts into Obsidian on my phone while walking. Those thoughts are on my laptop by the time I get home. I refactor my notes at my desk, and they're on my phone instantly. The VPS quietly keeps everything synchronized without me ever SSHing in to check on it.

Zero conflicts. Zero "oops, I edited the old version" moments. Zero subscription fees.

If You're Technical Enough to Care

You're probably already sold or already running something similar. If you're on the fence: one Saturday afternoon to set this up, then you never think about it again.

No subscription. No trusting a third-party with your data. No wondering if the sync service will still exist in five years or if they'll get acquired and enshittified.

Just files, syncing between your devices, like we've been doing since rsync was invented.

If you're still paying for Obsidian Sync after reading this... I mean, that's your choice. But at least know you have options.

Lets Connect:
Twitter
LinkedIn
Github

Top 10 Visual Studio Code Extensions for Enhanced Productivity

Prayush Adhikari — Sat, 28 Sep 2024 13:25:00 +0000

Top 10 VS Code Extensions You Absolutely Need (or Else!)

So, you’ve hopped on the Visual Studio Code train, huh? Welcome aboard! It’s sleek, it’s lightweight, and, oh boy, those extensions! They’re like sprinkles on a cupcake—totally necessary. Whether you’re a coding wizard or still figuring out the difference between a variable and a function, here’s a curated list of the top 10 VS Code extensions that you should definitely check out (because why not?).

1. Prettier - Code Formatter

Ever looked at your code and thought, “Yikes, what a mess”? Prettier is here to save the day! This opinionated code formatter works its magic on multiple languages, enforcing a consistent style. It's like having a professional organizer for your codebase. Trust me, your team will thank you (and maybe even throw you a party).

Get Started with Prettier!

2. ESLint

For all you JavaScript and TypeScript aficionados, ESLint is like that annoying friend who always points out your mistakes—except this one helps you write cleaner code. It spots and fixes issues in real-time, so you can avoid those embarrassing “uh-oh” moments during code reviews.

Learn More About ESLint

3. Live Server

Web developers, rejoice! The Live Server extension is your best friend. It sets up a local server and gives you live reload capabilities. So while you're frantically changing your HTML, CSS, and JavaScript, you’ll see those changes in real-time. No more refresh, refresh, refresh. Just sit back and watch the magic unfold!

Check Out Live Server

4. GitHub Copilot

Imagine having an AI-powered coding buddy who gets your coding style. GitHub Copilot offers suggestions for entire lines of code or functions, helping you tackle repetitive tasks and even suggesting cool solutions you might not have thought of. It’s like magic for your code!

Explore GitHub Copilot

5. Docker

For those of you diving into the world of containers (not the ones you keep your leftovers in), the Docker extension is a game changer. Manage and deploy Docker containers right from VS Code like a boss. It’s like having a personal assistant for your containerized applications, minus the coffee runs.

Get Docker Here

6. Vim

If you’re a fan of Vim’s powerful keybindings, you’re in luck. The Vim extension brings all those shortcuts to VS Code, so you can navigate and edit like a pro without ever lifting your fingers from the keyboard. It’s like giving your IDE superpowers, and you’ll feel unstoppable!

Try Vim for VS Code

7. Auto Rename Tag

For all the HTML/XML folks out there, Auto Rename Tag is a lifesaver. It automatically updates paired tags when you edit one of them, helping you avoid mismatches and keeping your code neat. It’s like having a cleanup crew for your tags.

Check Out Auto Rename Tag

8. Error Lens

Let’s face it: errors are a fact of coding life. But Error Lens makes spotting them way easier by showing error and warning messages directly in your code, right where the problem is. No more scrolling around looking for the issues—just fix it and move on!

Get Error Lens

9. CodeSnap

Love sharing your code online? CodeSnap makes it simple to take beautiful screenshots of your code, perfect for blog posts, social media, or documentation. Say goodbye to clunky screenshots and hello to polished, professional snaps.

Get CodeSnap

10. Thunder Client

Testing APIs has never been easier! Thunder Client is a super-lightweight REST API client right inside VS Code, making it a fantastic alternative to bulky tools like Postman. Test APIs without ever leaving your editor.

Discover Thunder Client

If you're looking to elevate your development experience with these extensions and more, feel free to check out my link to Visual Studio Code. It’s a fantastic resource that can help you get set up and make your coding life smoother than ever. So, gear up, download VS Code, and let’s make some code magic happen!

Join the PrayushDev Community!

Before you go, I'm excited to announce the launch of my weekly newsletter: PrayushDev! 🎉

Why should you subscribe? Here's what you'll get:

Bite-sized introductions to hot tech topics
Insider tips and tricks from the world of development
Early access to upcoming "React Unmasked" episodes
A chance to be part of a growing community of passionate devs

Don't miss out on this opportunity to stay at the cutting edge of tech. Subscribe now and let's grow together!

Subscribe to PrayushDev

Create your API using C++

Prayush Adhikari — Fri, 09 Aug 2024 15:19:41 +0000

Creating a C++ API with Drogon Framework

Introduction

In today's connected world, APIs are the backbone of modern applications, enabling different software systems to communicate with each other. While many developers rely on frameworks like Node.js, Python, or Java for building APIs, C++ is a powerful yet often overlooked option. This tutorial will walk you through creating your own API using C++ and the Drogon framework—a high-performance, production-ready framework for developing web applications.
View my repo on TheBookDB-API for reference: Click Here

What You'll Learn:

Setting up a C++ development environment for API creation
Creating a basic API using the Drogon framework
Managing routes, endpoints, and handling HTTP methods
Working with JSON data using JsonCpp
Best practices for structuring and deploying your API

Project Overview: TheBookDB

We'll build a simple book database API called TheBookDB. This API will allow users to:

Retrieve a List of Books
Filter Books
Add New Books
Update Existing Books
Delete Books

Key API Endpoints:

GET /books: Retrieve all books in the database
GET /books/filter: Filter books based on criteria like publication date and author
POST /books: Add a new book to the database
PATCH /books/{bookID}: Update an existing book's details
DELETE /books/{bookID}: Delete a book from the database
PUT /books/{bookID}: Update or add a book

Technologies and Tools

C++
Drogon Framework
JsonCpp
Linux (Ubuntu)

Getting Started

Create a new Drogon project:

drogon_ctl create project <project_name>

Create a controller for the Book API:

drogon_ctl create controller Book

Navigate to the project directory and build:

cd <project_name> mkdir build cd build cmake .. make

Run the project:

./<project_name>

Prepare your books.csv file and place it in the root directory.
Update CMakeLists.txt to copy the CSV file to the build directory:

configure_file(${CMAKE_SOURCE_DIR}/books.csv ${CMAKE_BINARY_DIR}/books.csv COPYONLY)

Implementation

Book.h

Click here to view Book.h

Book.cpp

Click here to view Book.cpp

Running the API

After completing the implementation, build and run the application. Check the config.json file to find the port on which your application will run.

Join the PrayushDev Community

Subscribe to the weekly PrayushDev newsletter for:

Bite-sized introductions to hot tech topics
Insider tips and tricks from the world of development
Early access to upcoming "React Unmasked" episodes
A chance to be part of a growing community of passionate devs

Subscribe to PrayushDev

The Ultimate Roadmap to a Full-Stack Developer

Prayush Adhikari — Thu, 22 Feb 2024 11:40:23 +0000

We all wonder about the best way to start learning web development and how to become a successful full-stack developer in our career. Learning the surface is easy but as we dive deep into it most of us feel tired and give up easily. In this article, we will be discussing the various ways to start our web development journey and learn how we can become a great web developer.

Start Learning the Frontend Part First

Starting with learning the frontend part of web development is a common and logical first step for many aspiring developers. This approach allows learners to focus on the visible aspects of web development—the user interface and user experience—before delving into the complexities of backend development and server-side operations.

By beginning with frontend technologies such as HTML, CSS, and JavaScript, learners can quickly grasp the fundamentals of web design and interactivity. HTML provides the structure of a web page, and CSS styles, and enhances its appearance, while JavaScript adds dynamic behavior and interactivity to the user interface.

Starting with frontend development also enables learners to see immediate results, as they can create simple web pages and interactive elements relatively quickly. This can be highly motivating and encouraging, especially for beginners who may feel overwhelmed by the vastness of web development.

As learners progress in their frontend journey, they can explore advanced concepts and frameworks such as responsive design, CSS preprocessors like Sass or Less, and modern JavaScript libraries and frameworks like React.js, Angular, or Vue.js. These tools empower developers to build more complex and dynamic web applications while adhering to best practices and industry standards.

However, it's essential to recognize that front-end development is just one piece of the puzzle. To become a well-rounded and successful full-stack developer, learners should eventually expand their skills to include backend development, database management, and other related technologies.

In conclusion, starting with front-end development is a practical and effective way to begin your journey into web development. By mastering the frontend part first, you can build a solid foundation of skills and knowledge that will serve as a springboard for further learning and growth as you progress towards becoming a successful full-stack developer.

Dive into the Backend

After gaining a solid understanding of frontend development, the next logical step in becoming a full-stack developer is diving into backend development. While frontend development focuses on what users see and interact with, backend development deals with the behind-the-scenes functionality that powers web applications.

Backend development involves creating server-side logic, managing databases, handling authentication and authorization, and integrating with external services and APIs. It's the backbone of any dynamic web application, enabling it to handle complex business logic, process data, and respond to user requests effectively.

Here are some key aspects to consider when diving into backend development:

Choose a Backend Language/Framework: Start by selecting a backend programming language and framework to focus on. Popular choices include Node.js (JavaScript), Python (Django or Flask), Ruby on Rails, and Java (Spring Boot). Each language and framework has its strengths and use cases, so choose one that aligns with your goals and interests.
Learn Server-side Concepts: Familiarize yourself with server-side concepts such as routing, middleware, request handling, and response generation. Understand how servers communicate with clients using protocols like HTTP and WebSocket, and learn about RESTful API design principles for building robust and scalable APIs.
Database Management: Gain proficiency in working with databases, both SQL and NoSQL. Learn how to design database schemas, perform CRUD (Create, Read, Update, Delete) operations, and optimize database performance. Common databases include MySQL, PostgreSQL, MongoDB, and Firebase Firestore.
Authentication and Authorization: Understand the concepts of authentication (verifying user identities) and authorization (granting access rights). Learn how to implement user authentication mechanisms such as password hashing, JWT (JSON Web Tokens), OAuth, and session management to secure your applications.
API Integration: Explore how to integrate your backend with external services and APIs to extend the functionality of your applications. This may involve consuming third-party APIs for tasks like payment processing, sending emails, or accessing social media platforms.
Testing and Debugging: Learn how to write unit tests and perform integration testing to ensure the reliability and robustness of your backend code. Familiarize yourself with debugging tools and techniques to identify and fix issues efficiently.
Deployment and DevOps: Gain experience in deploying and managing backend applications in production environments. Learn about DevOps practices such as continuous integration, continuous deployment (CI/CD), containerization (using Docker), and orchestration (with tools like Kubernetes) to automate the deployment process and ensure scalability and reliability.

By diving into backend development, you'll complement your frontend skills and become proficient in building full-fledged web applications from end to end. Embrace the challenges, stay curious, and continue learning as you embark on your journey to becoming a successful full-stack developer.

Some of the resources are

MDN Web Docs - Mozilla Developer Network offers comprehensive documentation on HTML, CSS, JavaScript, and web standards.
MDN Web Docs
W3Schools - Provides tutorials, references, and exercises on HTML, CSS, JavaScript, and other web technologies.
W3Schools
freeCodeCamp - Offers free online courses on web development, including HTML, CSS, JavaScript, and backend technologies like Node.js and Express.js.
freeCodeCamp
CSS-Tricks - A web design community that provides tutorials, articles, and resources on CSS, front-end development, and design trends.
CSS-Tricks
The Net Ninja - YouTube channel offering tutorials on frontend technologies like HTML, CSS, JavaScript, and frameworks like React and Vue.js.
The Net Ninja
Stack Overflow - Q&A platform where developers can ask questions and find answers on a wide range of topics related to frontend and backend development.
Stack Overflow
DevDocs - Aggregates documentation from various sources into a single, easy-to-navigate interface, covering frontend and backend technologies.
DevDocs
Node.js Official Documentation - Offers comprehensive documentation and guides for Node.js, a popular backend JavaScript runtime.
Node.js Documentation
Django Documentation - Official documentation for Django, a high-level Python web framework for backend development.
Django Documentation
Express.js Documentation - Official documentation for Express.js, a minimal and flexible Node.js web application framework for backend development.
Express.js Documentation

Join the PrayushDev Community

Subscribe to the weekly PrayushDev newsletter for:

Bite-sized introductions to hot tech topics
Insider tips and tricks from the world of development
Early access to upcoming "React Unmasked" episodes
A chance to be part of a growing community of passionate devs

Subscribe to PrayushDev

Support My Journey as a Microsoft Student Ambassador

Help me reach my goal as a Microsoft Student Ambassador:

Visit my special link: Microsoft Student Ambassador
Explore the page and learn about the initiatives
Share the link with your friends and colleagues

My goal is to reach 250 visitors. Your support contributes to tech education and community building.

Thank you for being part of this journey!

DEV Community: Prayush Adhikari

MongoDB: Zero to Advanced (The Real Guide Nobody Else Will Write)

Let's Talk About Databases First (Bear With Me)

SQL vs NoSQL: The Fight That Never Ends

Setting Up MongoDB (The Easy Way)

Step 1: Create Your Atlas Account

Step 2: Create Your First Cluster

Step 3: Set Up Access

Step 4: Get Your Connection String

Step 5: Install MongoDB Compass

Core Concepts: The Building Blocks

1. Database

2. Collection

3. Document

4. _id Field

CRUD Operations: The Heart of Everything

Create: Adding Data

Read: Finding Data

Update: Changing Data

Delete: Removing Data

Data Modeling: The Part That Actually Matters

Embedding (Nesting Data Inside a Document)

Referencing (Like Foreign Keys in SQL)

Intermediate Queries: Leveling Up

Querying Arrays

Querying Nested/Embedded Documents

Logical Operators

The Aggregation Framework: Where the Real Magic Happens

Common Aggregation Stages

Real Example: Blog Stats

Indexing: Making Your Database Fast

When to Add an Index

Transactions: When You Need ACID Guarantees

Connecting MongoDB to Node.js (Let's Build Something Real)

Setup

Basic Connection

Building a Simple CRUD API

Mongoose: The Better Way to Use MongoDB with Node.js

Atlas Search and Vector Search: The 2025-2026 Stuff

Atlas Search

Vector Search (For AI Apps)

Time Series Collections (MongoDB 8.x)

The Real Secret to MongoDB Mastery

What's Next?

Let's Connect

Database Indexing Explained Like You're 5 (Then Like You're a Senior Dev)

The 5-Year-Old Explanation

The Real World Problem

How Indexes Actually Work (Getting Technical)

The B-Tree Structure

Types of Indexes (Because One Size Doesn't Fit All)

1. Single Column Index

2. Composite Index

3. Unique Index

4. Partial Index

5. Full-Text Index

The Dark Side: When Indexes Hurt You

Storage Cost

Write Performance

The Wrong Index Is Worse Than No Index

Common Indexing Mistakes (Learn from My Pain)

Mistake 1: Indexing Everything

Mistake 2: Ignoring Index Order in Composite Indexes

Mistake 3: Not Analyzing Your Indexes

Mistake 4: Forgetting About Covering Indexes

Mistake 5: Over-Optimizing Too Early

Advanced Strategies (Senior Dev Territory)

Strategy 1: Index-Only Scans

Strategy 2: Conditional Indexes with Expressions

Strategy 3: Index Hints (Use Sparingly)

Strategy 4: Monitoring Index Usage

Real-World Example: My Blog Optimization

The Practical Checklist

Tools I Actually Use

pgAdmin

MySQL Workbench

Database Monitoring

The Bottom Line

Let's Connect

Setting Up Your Command Line Assistant with Google Services (The Complete Guide)

4. `_id` Field