Forem: Suraj Sharma

Why to choose PostgreSQL over MongoDB in 2026

Suraj Sharma — Tue, 27 Jan 2026 23:05:31 +0000

For a long time, MongoDB was the default choice when applications needed flexibility or scale. The argument was simple: SQL databases are rigid, NoSQL databases scale better.

That argument no longer holds true in 2026.

Modern PostgreSQL supports structured schemas, semi-structured data, vector search, advanced indexing, and complex queries, all in one system. In many real production systems, using PostgreSQL alone avoids the need for MongoDB entirely.

This article explains why PostgreSQL is often a better choice than MongoDB today, based on real backend systems running at scale.

Structured schema (because it matters in production)

In production systems, data consistency matters more than initial flexibility.

PostgreSQL enforces:

Strong data types
Primary and foreign keys
Constraints and relationships

This prevents invalid data from entering the system in the first place.

In one of our systems (Merlin an AI-driven real estate search platform used by 60K+ active users), PostgreSQL was the source of truth for:

Properties
Canonical locations
Images
Metadata relationships

With millions of records and daily ingestion of ~120K properties, schema enforcement helped catch errors early instead of letting bad data silently propagate.

MongoDB’s schemaless model pushes validation to the application layer. This works initially, but as systems grow, different document shapes start appearing for the same logical entity. Debugging and migrating this later is painful.

JSONB for unstructured data (without losing relational guarantees)

A common reason for choosing MongoDB is storing flexible or evolving data.

PostgreSQL already solves this with JSONB.

You can store:

Dynamic attributes
Search filters
Derived metadata
Optional fields

…directly inside relational tables.

In our search backend:

Core entities (property, location, image) were modeled relationally
Flexible attributes and filters were stored using JSON/JSONB
GIN indexes were used to query JSON fields efficiently

This allowed us to:

Avoid unnecessary JOINs on hot paths
Keep strong consistency for critical data
Avoid running a separate NoSQL database just for flexibility

Instead of choosing either relational or document storage, PostgreSQL lets you combine both.

Minimize JOINs where needed (without denormalizing everything)

JOINs are often blamed for performance issues.

In our system:

Complex JOINs were used where correctness mattered
JSONB and caching were used where read performance mattered
Redis JSON was used for fast hybrid search paths

This approach reduced query complexity without duplicating core data everywhere.

MongoDB often pushes developers to denormalize aggressively, which leads to:

Data duplication
Hard-to-maintain update logic
Eventual consistency bugs

PostgreSQL gives you more control: normalize first, optimize selectively.

Complex SQL queries are an advantage

PostgreSQL’s biggest strength is still SQL.

SQL allows you to:

Express complex relationships clearly
Debug queries easily
Optimize step by step
Reuse logic across services

Early versions of our search system relied on complex SQL queries across multiple tables. When latency increased, we didn’t rewrite the data model but we changed the architecture.

We separated:

Relational filtering (PostgreSQL)
Vector similarity search (pgVector / Redis)
Keyword and fuzzy matching (Elasticsearch)

The result:

Query latency dropped from ~5 minutes to ~10 seconds
SQL remained readable and maintainable

MongoDB would require aggregation pipelines with multiple stages ($lookup, $unwind, $group), which become harder to reason about as complexity grows.

SQL scales better cognitively than aggregation pipelines.

PostgreSQL is AI-ready (without MongoDB)

There’s a common assumption that AI workloads require NoSQL databases.

In reality:

PostgreSQL + pgVector handled 1.2M+ image embeddings
Vector similarity was separated from relational queries
Multi-stage retrieval (keyword → vector → re-ranking) improved both performance and relevance

PostgreSQL acted as:

The source of truth
The filter engine
The relational backbone

Specialized systems handled specialized workloads without replacing PostgreSQL.

This architecture scaled to ~10K searches per day while keeping infrastructure costs under control.

Canonical data modeling works better in relational databases

Location search is a good example.

We stored canonical locations in PostgreSQL and used Elasticsearch only for fuzzy user input matching. User-entered locations were mapped to canonical IDs, which were then used for downstream queries.

This eliminated:

Repeated database calls
Duplicate location representations
Inconsistent location data

Relational constraints ensured correctness. MongoDB would push this logic into application code instead.

Fewer systems, lower operational complexity

Every additional database increases:

Infrastructure cost
Monitoring overhead
Consistency challenges
Developer cognitive load

In our backend, PostgreSQL remained the primary database. Redis and Elasticsearch were supporting systems and not sources of truth.

MongoDB was never required.

In 2026, reducing stack complexity is often more valuable than adding another database optimized for a narrow use case.

Conclusion

PostgreSQL in 2026 is no longer “just a relational database”.

It provides:

Strong schemas for production safety
JSONB for flexible data
Advanced indexing
Vector search support
Powerful SQL for complex queries

For many real-world systems, PostgreSQL can replace MongoDB entirely while reducing risk, cost, and long-term maintenance.

MongoDB still has valid use cases, but it should be a deliberate choice and not a default one.

Building Vaani - A Conversational AI Resume Reviewer and Writer

Suraj Sharma — Tue, 13 Jan 2026 02:30:42 +0000

The Problem: Why Job Seekers Struggle to Show Their Impact

Let me be honest. I've reviewed hundreds of resumes, and I see the same problem over and over again.

Job seekers have real experience. They've built things, solved problems, led teams. But when they sit down to write their resume, something breaks. They write generic bullet points like:

Responsible for developing features
Worked with a team on projects
Improved system performance

These bullets don't tell the story. They don't show impact. Recruiters want to know: What changed? Who benefited? Why did it matter?

The real problem isn't that job seekers lack experience. It's that they don't know how to articulate their impact in a way that resonates with hiring managers.

This is where Vaani comes in.

What is Vaani? Your AI Resume Copilot

Vaani is an AI resume copilot I built to solve this exact problem. It's not just another resume builder. It's a conversational AI system that:

Parses your resume – Extracts your experience, skills, education, and background into structured data
Classifies your seniority – Calculates total years of experience to understand your career level
Analyzes your work experiences – Identifies which experiences have strong impact signals and which are missing them
Asks the right questions – Guides you through a conversation to uncover real business impact from your work
Refines your impact stories – Transforms generic bullets into compelling achievement statements
Maintains context – Remembers everything across the entire conversation using persistent memory

The key insight? Impact isn't invented. It's uncovered. Most job seekers have amazing stories buried in their experience. They just need someone (or something) to ask the right questions to bring them out.

How I Architected Vaani: The Three Pillars

Vaani is built on three core pillars: Agentic Workflow, Memory System, and Interactive State Management.

Pillar 1: Agentic Workflow

An agentic workflow means Vaani doesn't just respond to user input. It orchestrates multiple AI agents that work together to guide you through a structured review process.

Here's how it works:

Agent 1: Seniority Classifier

Analyzes your work experience to calculate total years of experience
Classifies you as Junior, Mid, or Senior level
This context helps all other agents understand your career stage

Agent 2: Impact Analysis Agent

Reviews each of your work experiences
Identifies which experiences have strong impact signals (outcomes, metrics, business value)
Flags experiences that are missing impact details
Provides reflection prompts to help you recall impact

Agent 3: Experience Selector Agent

Orchestrates which experience to focus on next
Prioritizes most recent experiences with missing impact
Ensures you work through experiences systematically

Agent 4: Impact Analysing Agent

This is where the magic happens
Asks targeted, conversational questions about your work
Focuses on outcomes: What changed? Who benefited? Why did it matter?
Helps you articulate real business impact

Agent 5: Impact Refinement Agent

Takes your free-text impact description
Translates it into clear, business-relevant language
Produces resume-ready bullet points
Ensures accuracy and authenticity

Pillar 2: Memory System (Redis-Backed)

Here's the problem with most AI tools: they forget context. You tell them something in message 1, and by message 10, they've lost track.

Vaani uses a persistent memory system backed by Redis. Every conversation is stored with:

Resume sections – Your parsed resume data (name, skills, experience, education)
Metadata – Total years of experience, seniority level
Impact analysis results – Which experiences have strong impact, which need work
Conversation history – Every message exchanged
Current state – Which experience you're working on, what stage you're in
Rewritten resume – The improved version being built

This memory persists for 24 hours, so you can close the browser and come back later. Vaani remembers everything.

The memory structure looks like this:

{
  "resume_sections": {
    "name": "John Doe",
    "hard_skills": ["Python", "React", "AWS"],
    "work_experiences": [...]
  },
  "metadata": {
    "total_years_experience": 5,
    "seniority_level": "Mid"
  },
  "current_state": {
    "current_experience_index": 0,
    "current_experience_processed": false,
    "current_step": "impact_analysing",
    "state": "processing"
  },
  "rewritten_resume": {...}
}

Pillar 3: Interactive State Management

Vaani doesn't process everything at once. It moves through discrete stages, each with a clear purpose:

Seniority Classification → Calculate years of experience
Impact Analysis → Analyse all work experiences for impact signals
Experience Selection → Choose which experience to focus on next
Impact Elicitation → Ask targeted questions about that experience
Impact Refinement → Transform answers into resume-ready bullets
Iteration → Move to next experience and repeat

Each stage has a current state that tracks:

Which experience you're working on
Whether that experience has been processed
What step you're currently in
Overall processing status

This prevents confusion and ensures the workflow guides you systematically through your resume.

The Agentic Workflow in Action: A Real Example

Let me walk you through how Vaani works with a real job seeker.

You: Upload your resume (PDF)

Vaani: Parses it and says: "Got it! I see you're a Software Engineer with 5 years of experience at three companies. You have Python, React, and AWS skills. Let me analyze your experiences..."

Vaani: (Analyzing) "Calculating your seniority level... You have 5 years of experience, so you're at a Mid level. Now let me review each of your work experiences to see where you have strong impact stories and where we can dig deeper."

Vaani: "I've analysed your experiences. Your most recent role at TechCorp has some impact signals, but it's missing details. Let's start there. Tell me about your biggest achievement in that role. What did you build or improve? What changed because of your work?"

You: "Well, I built a microservices architecture that improved performance."

Vaani: "Great! Let's dig deeper. How much did performance improve? Who benefited from this? Why did it matter to the business?"

You: "Oh! We reduced API latency by 60%, which meant our mobile app users had a much faster experience. That led to a 15% increase in daily active users."

Vaani: "Perfect! That's real impact. Here's how I'd write that as a resume bullet:

Architected microservices migration reducing API latency by 60%, enabling 15% increase in daily active users and improving experience for users.

Does that feel accurate?"

You: "Yes! That's so much better than what I had."

Vaani: "Great. Let's move to your next role at PreviousCorp. Tell me about your biggest impact there..."

And so on. By the end, you have a completely rewritten resume with impact-driven bullets for each experience.

The Architecture Diagram

Here's how all the pieces fit together:

┌─────────────────────────────────────────────────────────────┐
│                    VAANI ARCHITECTURE                       │
└─────────────────────────────────────────────────────────────┘

┌──────────────────┐
│  User Interface  │
│  (Web/Mobile)    │
└────────┬─────────┘
         │
         ▼
┌──────────────────────────────────────────────────────────────┐
│              WebSocket Connection (Real-time)                │
└────────┬─────────────────────────────────────────────────────┘
         │
         ▼
┌──────────────────────────────────────────────────────────────┐
│           Vaani Backend (Go + Genkit)                        │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐     │
│  │  Message Router                                     │     │
│  │  - Routes messages to appropriate agent             │     │
│  │  - Manages conversation flow                        │     │
│  │  - Tracks current state                             │     │
│  └────────────────┬────────────────────────────────────┘     │
│                   │                                          │
│     ┌─────────────┼──────────────┬──────────────┐            │
│     ▼             ▼              ▼              ▼            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │Seniority │  │Impact    │  │Experience│  │Impact    │      │
│  │Classifier│  │Analysis  │  │Selector  │  │Analysis  │      │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘      │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐    │
│  │  Impact Refinement Agent                             │    │
│  │  - Transforms user answers into resume bullets       │    │
│  │  - Maintains accuracy and authenticity               │    │
│  └──────────────────────────────────────────────────────┘    │
│                                                              │
└──────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────┐
│              Memory Layer (Redis)                            │
│                                                              │
│  Key: memory:{chat_id}                                       │
│  Value: {                                                    │
│    resume_sections,                                          │
│    metadata (seniority, experience),                         │
│    impact_analysis_results,                                  │
│    conversation_history,                                     │
│    current_state,                                            │
│    rewritten_resume                                          │
│  }                                                           │
│  TTL: 24 hours                                               │
└──────────────────────────────────────────────────────────────┘
                             │
                             ▼
┌──────────────────────────────────────────────────────────────┐
│              LLM Layer                                       │
│                                                              │
│  - Structured outputs for parsing                            │
│  - Prompt engineering for each agent                         │
│  - JSON schema validation                                    │
└──────────────────────────────────────────────────────────────┘

The Memory Flow: How Context Persists

Here's how memory works across a conversation:

User uploads resume
        │
        ▼
Parse resume → Store in Redis memory
        │
        ▼
Classify seniority level
        │
        ▼
Retrieve memory → Add seniority data → Update Redis
        │
        ▼
Analyze all work experiences for impact
        │
        ▼
Retrieve memory → Add impact analysis → Update Redis
        │
        ▼
Select first experience to work on
        │
        ▼
Ask impact questions about that experience
        │
        ▼
Retrieve memory → Add conversation → Update Redis
        │
        ▼
Refine impact into resume bullet
        │
        ▼
Retrieve memory → Add refined bullet → Update Redis
        │
        ▼
Move to next experience (repeat)
        │
        ▼
User closes browser (memory persists for 24 hours)
        │
        ▼
User returns next day
        │
        ▼
Retrieve memory → Continue from where they left off

This is powerful because it means Vaani never loses context. You can have a conversation over multiple days, and it remembers everything. You can close the browser mid-conversation and come back later to continue exactly where you left off.

Why This Architecture Matters

Most AI resume tools are stateless. They don't remember context. You tell them something, they respond, and that's it. If you want to refine something, you have to re-explain everything.

Vaani is stateful and agentic. It:

Remembers everything – Via Redis memory that persists for 24 hours
Orchestrates multiple agents – Each with a specific job (seniority classification, impact analysis, elicitation, refinement)
Maintains workflow state – Knows exactly which experience you're working on and what stage you're in
Asks intelligent questions – Based on your specific resume and career level
Never fabricates – Only enhances what you confirm as true
Guides systematically – Works through your experiences one by one, ensuring nothing is missed

This is why Vaani produces better results than generic AI tools. It's not just generating text. It's guiding you through a structured conversation to uncover and articulate your real impact.

The Results: What Users Get

After going through Vaani, users get:

Impact-driven resume bullets – Focused on outcomes, not tasks
Deeper self-awareness – You understand your own impact better
Confidence in your story – You can articulate your value clearly
A repeatable process – You know how to uncover impact for any role
Better resume quality – Each bullet is specific, measurable, and authentic

Users report that their resume bullets are significantly stronger after Vaani. Instead of generic statements like "Improved system performance," they have specific, impact-driven bullets like "Architected microservices migration reducing API latency by 60%, enabling 15% increase in daily active users."

Building Vaani: Key Lessons

If you're building AI systems, here are the key lessons I learned:

State matters – Stateless AI is limited. Persistent memory changes everything. Users can close the browser and come back later.
Agents are powerful – Multiple specialized agents beat one general-purpose model. Each agent does one thing well.
Accuracy over polish – Never fabricate. Users trust systems that maintain fidelity. It's better to ask a clarifying question than to guess.
Conversation > generation – Asking the right questions is more powerful than generating answers. The user has the knowledge; you just need to help them articulate it.
Workflow design – Clear stages and state management prevent confusion. Users should always know where they are in the process.
Systematic over random – Guide users through experiences systematically. Don't jump around randomly.

Try Vaani Today

If you're struggling to tailor your resume, or if you want to uncover the real impact in your experience, try Vaani. It's free to start, and it works for any role in software, AI, ML, and data.

Visit try-vaani to get started.

Your resume has more power than you think. Vaani helps you unlock it.

[Boost]

Suraj Sharma — Fri, 26 Dec 2025 04:51:15 +0000

Suraj Sharma

Dec 26 '25

Solving Latency and Pagination in Image and Keyword Based Property Search

#systemdesign #machinelearning #postgres #performance

Comments

3 min read

Solving Latency and Pagination in Image and Keyword Based Property Search

Suraj Sharma — Fri, 26 Dec 2025 03:14:39 +0000

At my company, we realized that users do not search for homes the way traditional search systems expect. Some users type simple keywords. Others describe what they want to see in images, for example “homes with large glass windows in the living room” or “backyards with large trees”.

Our existing search system was not designed for this behavior.

Property descriptions usually do not contain visual details like trees, lighting, or window style. Because of this, keyword search and vector search on text were not enough. We needed image based search at scale.

At the same time, the implementation was not scalable. We had around 1.3 million image embeddings created using Nomic vision models. Vector search was done inside PostgreSQL using pgvector, and most of the logic was written as complex SQL queries. As traffic and data increased, performance degraded badly. Search latency went up to 5 minutes, making the feature unusable.

Ownership and Approach

As a senior software engineer, I took ownership of fixing both the performance and correctness of Deep Search.

One key decision I made was to keep the system deterministic and not use LLMs for ranking or retrieval. LLMs are useful, but they are non deterministic and hard to control at scale.

I used an LLM only to understand user intent. The LLM parses the user query and extracts:

Hard filters like number of bedrooms or location
A flag that indicates whether image based search is required

For example:

“2 bedroom apartment in Manhattan” only needs deterministic filters and keyword search
“2 bedroom house with backyard having large trees” requires visual understanding and triggers Deep Search

This keeps LLM usage limited and makes the rest of the system predictable and debuggable.

Challenges Found During Implementation

While redesigning the system, I discovered a major issue with how results from different retrieval systems were merged.

BM25 search has its own ranking and pagination. Vector search also has its own ranking and pagination. When results were paginated first and then merged, pagination broke completely.

Page 2 from BM25 and Page 2 from vector search did not represent the same set of results. Some pages contained mostly vector matches, some had none, and rankings changed between requests. This caused unstable and inconsistent results, which is not acceptable for a production search system.

This problem required rethinking how ranking and pagination were handled.

Solution

When Deep Search is triggered, I built a hybrid search pipeline with clear separation of concerns:

Hard deterministic filters
BM25 full text search using RedisSearch
Vector search on property images using pgvector

The key change was that none of these systems paginate independently anymore.

To merge results correctly, I implemented Reciprocal Rank Fusion, which is designed to combine ranked lists from different search engines.

For each property, we compute a single hybrid score:

BM25 rank is converted into a reciprocal score
Vector similarity scores are normalized
We apply weights based on whether Deep Search is triggered

hybridScore = alphaBM25 * bm25Score + betaVector * (vecScore / maxVec)

Only after this unified hybrid score is computed do we apply pagination. This guarantees stable ordering across pages.

Result

This approach solved both performance and ranking issues.

Latency reduced from around 5 minutes to under 10 seconds
Pagination is stable and deterministic
Visual matches surface naturally when users ask for visual features
Keyword intent still influences ranking
Results are consistent across pages

10 Classical ML Algorithms Every Fresher Should Learn in 2026

Suraj Sharma — Wed, 24 Dec 2025 00:32:52 +0000

This guide covers the 10 classical machine learning algorithms every fresher should learn. Each algorithm is explained with why it matters, how it works at a basic level, and when you should use it. By the end, you'll have a solid foundation to tackle real-world machine learning problems.

1. Linear Regression

What it does: Linear Regression models the relationship between input features and a continuous target value using a straight line (or hyperplane in multiple dimensions).

Why learn it: This is the starting point for understanding machine learning mathematically. It teaches you about loss functions, gradients, and how models learn from data. Linear Regression is simple but powerful for many real-world problems like predicting house prices, stock values, or sales forecasts.

When to use it: Use Linear Regression when you have a continuous target variable and suspect a linear relationship between features and the target. It's fast, interpretable, and works well as a baseline model.

Real example: Predicting apartment rent based on square footage, location, and amenities.

2. Logistic Regression

What it does: Despite its name, Logistic Regression is a classification algorithm. It predicts the probability that an instance belongs to a particular class, typically used for binary classification (yes/no, spam/not spam).

Why learn it: Logistic Regression is everywhere in industry. It's used in fraud detection, email spam filtering, disease diagnosis, and customer churn prediction. Understanding it teaches you about probabilities, decision boundaries, and how to convert regression into classification.

When to use it: Use it for binary classification problems where you need interpretable results and probability estimates. It's also a great baseline for classification tasks.

Real example: Predicting whether a customer will buy a product (yes/no) based on their browsing history and demographics.

3. k-Nearest Neighbors (KNN)

What it does: KNN classifies data points based on the classes of their k nearest neighbors in the training dataset. If most neighbors belong to class A, the new point is classified as A.

Why learn it: KNN is intuitive and teaches you about distance metrics (how to measure similarity between data points). It's a lazy learning algorithm, meaning it doesn't build a model during training but instead stores all training data and makes predictions at test time.

When to use it: Use KNN for small to medium-sized datasets where you need a simple, interpretable classifier. It works well for image recognition, recommendation systems, and pattern matching.

Real example: Recommending movies to a user based on movies watched by similar users.

4. Naive Bayes

What it does: Naive Bayes is a probabilistic classifier based on Bayes' theorem. It assumes that all features are independent of each other (the "naive" assumption) and calculates the probability of each class given the features.

Why learn it: Naive Bayes is fast, scalable, and surprisingly effective despite its simplistic assumptions. It's widely used in text classification, spam detection, and sentiment analysis. Understanding it teaches you about probability and Bayesian thinking.

When to use it: Use Naive Bayes for text classification, spam detection, and when you need a fast, lightweight classifier. It works especially well with high-dimensional data like text.

Real example: Classifying emails as spam or not spam based on word frequencies.

5. Decision Trees

What it does: Decision Trees make predictions by recursively splitting data based on feature values. Each split creates a branch, and the tree continues until it reaches a leaf node that makes a prediction.

Why learn it: Decision Trees are highly intuitive and interpretable. You can visualize exactly how the model makes decisions. They also teach you about feature importance and how to handle both classification and regression problems.

When to use it: Use Decision Trees when you need interpretability and can afford some overfitting. They work well for both classification and regression and handle non-linear relationships naturally.

Real example: Deciding whether to approve a loan based on credit score, income, and employment history.

6. Random Forest

What it does: Random Forest combines multiple Decision Trees to improve accuracy and reduce overfitting. Each tree is trained on a random subset of data and features, and predictions are made by averaging (regression) or voting (classification) across all trees.

Why learn it: Random Forest is powerful out-of-the-box and often works well without much tuning. It's one of the most popular algorithms in industry because it balances accuracy with interpretability. Understanding ensemble methods is crucial for modern machine learning.

When to use it: Use Random Forest as your first choice for most classification and regression problems. It handles missing values, non-linear relationships, and feature interactions well.

Real example: Predicting customer churn by combining predictions from multiple decision trees trained on different data subsets.

7. Support Vector Machines (SVM)

What it does: SVM finds the optimal boundary (hyperplane) that separates classes by maximizing the margin between them. It can also handle non-linear problems using kernel tricks.

Why learn it: SVM has strong theoretical foundations and works exceptionally well for high-dimensional data. Understanding SVM teaches you about optimization, margins, and kernel methods—concepts that appear throughout machine learning.

When to use it: Use SVM for binary classification problems, especially with high-dimensional data. It's particularly effective for text classification and image recognition.

Real example: Classifying handwritten digits (0-9) in image recognition tasks.

8. k-Means Clustering

What it does: k-Means is an unsupervised algorithm that groups data points into k clusters based on similarity. It iteratively assigns points to the nearest cluster center and updates centers until convergence.

Why learn it: k-Means introduces you to unsupervised learning and clustering concepts. It's simple, fast, and widely used for customer segmentation, image compression, and data exploration.

When to use it: Use k-Means when you want to discover natural groupings in unlabeled data. It's great for exploratory data analysis and customer segmentation.

Real example: Grouping customers into segments based on purchase behavior for targeted marketing.

9. Principal Component Analysis (PCA)

What it does: PCA is a dimensionality reduction technique that transforms features into a smaller set of uncorrelated components that capture most of the variance in the data.

Why learn it: PCA teaches you about feature reduction, which is crucial for handling high-dimensional data. It helps with visualization, noise removal, and improving model performance by reducing computational complexity.

When to use it: Use PCA when you have many features and want to reduce dimensionality while preserving information. It's useful for visualization, noise reduction, and speeding up model training.

Real example: Reducing 784 pixel features in handwritten digit images to 50 principal components for faster classification.

10. Gradient Boosting (GBM)

What it does: Gradient Boosting builds models sequentially, where each new model corrects errors made by previous models. It combines weak learners (usually decision trees) into a strong predictor.

Why learn it: Gradient Boosting is the foundation for modern tools like XGBoost, LightGBM, and CatBoost that dominate machine learning competitions and industry applications. Understanding it prepares you for state-of-the-art techniques.

When to use it: Use Gradient Boosting for both classification and regression when you want maximum accuracy. It requires careful tuning but often produces the best results.

Real example: Predicting house prices by sequentially building trees that correct previous prediction errors.

Your Learning Path

Practice each algorithm with real datasets from Kaggle or GitHub. Build projects, understand the math, and experiment with different parameters. This foundation will serve you well throughout your machine learning career.

How to add google analytics to a Next.js website

Suraj Sharma — Sun, 27 Dec 2020 10:49:54 +0000

In this tutorial, you'are going to learn how you can add Google Analytics to your Next.js Website.

A typical Google Analytics JavaScript code looks like this

<script async src="https://www.googletagmanager.com/gtag/js?id=${YOUR_TRACKING_ID}"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', ${YOUR_TRACKING_ID});
</script>

Adding this directly inside the Head component on your Next project does not work because React converts it to a string before rendering,
which helps prevent cross-site-scripting attack

The best way to add the google analytics script

Open your _document.js file, use the below code to insert the script into your _document.js file.

import Document, { Head, Main, NextScript } from 'next/document';

export default class MyDocument extends Document {
  render() {
    return (
      <html lang="en">
        <Head>
          <script async src="https://www.googletagmanager.com/gtag/js?id=${YOUR_TRACKING_ID}"></script>
          <script
            async
            dangerouslySetInnerHTML={{
              __html: `window.dataLayer = window.dataLayer || [];
              function gtag(){dataLayer.push(arguments);}
              gtag('js', new Date());

              gtag('config', ${YOUR_TRACKING_ID});`
            }}
          />
        </Head>
        <body>
          <Main />
          <NextScript />
        </body>
      </html>
    )
  }
}

Replace the ${YOUR_TRACKING_ID} variable with your google analytics tracking ID

Now when you reload your website you can notice one 'Active Users right now' on your google analytics dashboard.

How to build a dark mode theme using React Material UI, React context API and React hooks

Suraj Sharma — Sat, 15 Aug 2020 18:09:43 +0000

This article is about creating your own 'ThemeProvider' component to toggle between the light mode and dark mode built using React Context API and React hooks useMemo() and useCallback() even created a new custom hook useChangeTheme()

I recently added a button to toggle between light mode and dark mode on my personal blog, for that I created a separate library called 'react-material-ui-dark-mode'

If you're interested in reading more about how to build own your toggle button or want to use my library in your projects.

Follow my blog post on my personal website or you can fork the GitHub repository react-material-ui-dark-mode

Please leave your feedback on the comment box below.

Thank You!

Which URL Shortener Tool Do You Use and Why?

Suraj Sharma — Sat, 02 May 2020 17:02:43 +0000

There are many URL shortener tools available in the market some are free and many require paid subscriptions to use their service.

Here are few URL shortener tools I already know about:

bitly,
tinyURL,
rebrandly,
shorturl.at
t.co - twitter

All the above tools are fast and secure, they also come with url hit tracker that let you know how many clicks your short links get.

But the URL shortener tool I use is longurl.in, created by me and is free to use.

I created my own URL shortener tool using and named it longURL.in. It is built using Next.js, Typescript, serverless and MongoDB cloud.

Features:

It is fast and secure, communication is happening through HTTPS,
It always generates the same short URL for the same long URL, I did because I wanted a one to one mapping for a long URL, so that the database space consumption is less.
Shortened URLs read the metadata of the long urls when shared in social networking sites so that the short links don't look like spam links.
It is hosted in AWS cloud.

Not Implemented

It does not monitor how many hits a short URL gets.

Please comment which URL shortener tools do you use and why?

If you have any suggestion or feedback, please comment

Personal Blog Built using Nextjs and TypeScript

Suraj Sharma — Fri, 17 Apr 2020 01:56:18 +0000

This post is taken from my original post on my website surajsharma.net

I had a personal website before that was a single page static website built using HTML5,
materialize, and jquery. It is still there on Heroku click here →

I have been working on React for more than a year now. One day I thought of redesigning
my blog using React and Typescript but React has a major problem in terms of SEO, because of
client-side rendering, search engines' bot are unable to scrape content from websites resulting
in zero organic views.

These were the requirements I had for my new personal website :

support for blog posts
Typescript support😘
SEO friendly (must have)
Progressive Web App (everyone is doing it why not me)

Research

I have read about React frameworks Nextjs and Gatsby before, they are static site generators on
the build time, which means the website has static HTML and CSS files with fully loaded content
from the server itself, unlike React where contents are generated on the client-side that is not
the best option for blog websites.

I chose Nextjs over Gatsby because of the two reasons:

Option for server-side rendering on every request,
Serverless support.

Is TypeScript supported?

Yes, Nextjs has the support for TypeScript

Development

I kick started my project with Material UI's nextjs-with-typescript example.

Whether to use Headless CMS or Markdown files for writing blogs?

   The choice was easy: Markdown🏆

Opensource projects like Babel, Nextjs and many other projects use Markdown files to create
their blog posts so the choice was clear, then came how to render markdown files to JSX?

For the time being, I'm using the markdown-to-JSX
library (I might migrate to MDX in future because of its capabilities to import react components on markdown
files and later embed them on jsx files to demonstrate live examples).

To Summarize, following framework and libraries are being used to complete the development of the website:

Nextjs
TypeScript
React Material UI
Markdown to JSX
HighLightjs
MongoDB Atlas to store email and name of subscribers who joined my newsletter.
Zeit Now- by default websites get the HTTPS support

Lighthouse Audit Report

View Report

Plans for future enhancements:

Improve the UX
Migrate to MDX
Improve the lighthouse report for accessibility, and performance
Progressive Web App
Send weekly newsletter

PS: I have a GitHub repository where I push all the posts of this blog.
If you find any mistake on my posts, please feel free to raise an issue or a pull request.

A Login Form built using React Hooks

Suraj Sharma — Sun, 01 Dec 2019 17:43:13 +0000

Created a simple login form using React, Typescript and React Material UI featuring useReducer and useEffect hooks.

A detailed article on How to build a React Login Form with Typescript and React hooks