DEV Community: Anita Kapal

How Blinkit, Zepto, and Instamart Turn Product Search Into Ad Revenue

Anita Kapal — Sun, 28 Jun 2026 12:03:14 +0000

How Quick Commerce Apps Become Advertising Platforms: A System Design Perspective

When we think about quick commerce apps, the first thing that comes to mind is speed.

10-minute delivery.
Dark stores.
Riders.
Inventory.
Real-time availability.
Fast checkout.

From the outside, quick commerce looks like a logistics problem.
But if we look at it from a developer and system design perspective, there is another interesting layer.
Quick commerce is not only about delivering products quickly.
It is also about deciding which products should be shown to the user first.
And that decision is where advertising enters the system.

My Observation as a Regular User

I frequently use apps like Instamart and Zepto for ordering groceries, snacks, and daily-use items.

Earlier, I used to think these apps were mostly about convenience. Open the app, search for what I need, add items to cart, pay, and get them delivered quickly.

But last month, I started noticing something interesting.

After I added products to my cart and moved toward checkout, the app started showing me suggestions to swap the product I had selected with another product.

For example, if I added one masala packet to my cart, the checkout page showed another similar product with a message like:

Swap for better value

The suggested product was bigger or cheaper, and the app encouraged me to replace the item already in my cart.
At first, this looked like a simple value-saving feature.
But from a developer perspective, this is much more than a small UI suggestion.

This is a real-time recommendation and monetization system working inside the checkout flow.
The user has already shown buying intent.
The user has already added an item to the cart.

Now the system has one more chance to influence the final purchase decision.

That is a very powerful moment.

Ads Are Moving Closer to Checkout

Another thing I noticed on Zepto is that the homepage is no longer only a product discovery page.

When I open the app, I now see a small video ad window on the bottom-left side of the screen.
It looks like a floating video ad, similar to what we see in social media apps or content platforms.
This is interesting because quick commerce apps are slowly adding more ad surfaces.

Earlier, ads were mostly banners or sponsored products.

Now we see:

This means quick commerce apps are not only becoming shopping platforms.

They are becoming attention platforms.

The user opens the app to buy groceries or snacks, but the app also gets an opportunity to show brand promotions at different points in the journey.

The User Thinks It Is a Shopping App

Let’s say a user opens a quick commerce app and searches for:

chips

The user expects a simple list of chips.
But from the system side, this is not just a search query.
It becomes a ranking problem.

The system needs to decide:

Which products match the query?
Which products are available near the user?
Which products can be delivered quickly?
Which products have better margins?
Which products are popular in that location?
Which products are sponsored by brands?
Which products should appear at the top?

So the final product list is not random.
It is the output of multiple systems working together.

Quick Commerce Search Is Not Just Search

In a normal search engine, the goal is relevance.
But in quick commerce, search ranking has more signals.

For example:

final_score =
    relevance_score
  + availability_score
  + location_score
  + popularity_score
  + personalization_score
  + sponsored_score

This is a simplified version, but it shows the idea.
A product may rank higher because it is relevant.
Another product may rank higher because it is available in the nearest dark store.
Another product may appear higher because the brand paid for sponsored placement.
This is how a shopping app slowly becomes an advertising platform.

The Digital Shelf

In offline supermarkets, brands pay for better shelf placement.
Products kept at eye level are more visible.
Products near the billing counter get more purchases.
Quick commerce has a digital version of this.

The homepage is a digital shelf.
Search results are a digital shelf.
Recommendation widgets are digital shelves.
The cart page is also becoming a digital shelf.
Even the checkout page is becoming a digital shelf.

For example:

Home Page
 ├── Banner Ads
 ├── Floating Video Ads
 ├── Recommended Products
 ├── Sponsored Products
 ├── Category Promotions
 └── Offers Near You

Cart Page
 ├── Swap for Better Value
 ├── Frequently Bought Together
 ├── Add More Items
 ├── Unlock Free Delivery
 └── Sponsored Suggestions

Every section can become ad inventory.
That means the platform can monetize not only on orders, but also the attention of the user.

Why Cart Recommendations Are So Powerful

The cart page is one of the most powerful places to influence a user.

Why?
Because the user is already very close to buying.
They are not casually browsing anymore.
They have selected products.
They are checking the final amount.
They are almost ready to pay.

So when the app shows a product replacement or upgrade at this stage, the probability of conversion can be high.

For example:

User added:
Aachi Masala Garam, 50g

App suggests:
Another garam masala product, 100g, at a lower effective price

From the user side, this looks like a helpful suggestion.

From the system side, this may involve:

Product similarity
Price comparison
Margin optimization
Inventory availability
Brand promotion
Sponsored ranking
Conversion prediction

The app is not just asking:

What did the user add?

It is also asking:

Can we suggest something better?
Can we increase order value?
Can we promote a specific brand?
Can we improve margins?
Can we unlock a discount threshold?
Can we make the user add or swap one more item?

This is where product design, recommendation systems, and advertising logic come together.

Why This Is Powerful for Brands

The most important thing about quick commerce is purchase intent.
When someone opens a quick commerce app, they are usually ready to buy.
They are not casually browsing like on social media.
They may want toothpaste, milk, snacks, cold drinks, instant noodles, butter, or masala right now.
This makes ads very valuable.
A sponsored product shown inside a quick commerce app is shown very close to the buying decision.

For example:

User searches: "cold drink"

Organic result:
- Coca-Cola
- Pepsi
- Sprite

Sponsored result:
- New energy drink brand

If the sponsored product appears at the right position, with the right price and availability, the user may buy it immediately.
That is why quick commerce ads can be powerful.
They are not just display ads.
They are ads connected to real-time buying intent.

What Developers See Behind This

As users, we only see a card, a banner, a video ad, or a swap suggestion.

But developers think about the systems behind it.

For example, when I see a “swap for better value” card in the cart, I think about the backend logic that may be running behind it.

Something like:

User adds product to cart
   ↓
Cart service updates cart
   ↓
Recommendation service checks similar products
   ↓
Inventory service checks availability
   ↓
Pricing service compares discounts
   ↓
Ad service checks sponsored campaigns
   ↓
Ranking service selects best replacement
   ↓
UI shows swap suggestion

The user only sees one simple suggestion.
But behind that suggestion, multiple services may be working together in real time.

What Systems Are Needed Behind This?

From a developer perspective, this business model needs many backend systems.

1. Search System

The search system handles user queries.

Example:

Query: "bread"
Location: Bangalore
Dark Store: DS_102
User ID: 84721

The system needs to return products that are relevant and available.
It cannot show items that are out of stock.

2. Inventory System

Inventory is very important in quick commerce.

If an ad promotes a product that is unavailable, the user experience becomes bad.
So the ad system must talk to the inventory system.

if product.available_in_dark_store == true:
    show_product()
else:
    hide_product()

This sounds simple, but at scale it becomes difficult because inventory changes constantly.

3. Ad Serving System

The ad serving system decides which sponsored product, banner, or video ad to show.
It may consider:

Brand campaign budget
Target city
Target category
User segment
Time of day
Product availability
Bid amount
Expected conversion rate
Placement type

Example:

Ad Campaign:
  brand: Snack Brand A
  category: Chips
  city: Mumbai
  budget: ₹5,00,000
  bid_per_click: ₹8
  target_keyword: "chips"
  placement: search_results

When a user searches for “chips” in Mumbai, this campaign becomes eligible.

Similarly, for a homepage video ad, the system may check:

Is the user in the target city?
Is the campaign active?
Has the user already seen this ad?
Is the brand targeting this category?
Is the video creative approved?
What is the frequency cap?

Then the app decides whether to show that small floating video window.

4. Ranking System

The ranking system combines organic and sponsored results.
This is where the business logic becomes interesting.
The platform cannot simply show the highest-paying ad everywhere.
If the ad is irrelevant, users may lose trust.
So the ranking system needs balance.

ranking_score =
    relevance * 0.4
  + availability * 0.2
  + personalization * 0.2
  + ad_score * 0.2

The actual system would be much more complex, but the basic idea is the same.
The platform has to optimize for revenue without affecting user experience.

5. Cart Recommendation System

This is the system behind swap suggestions and add-on recommendations.
It may use rules like:

If user added product A,
find products from the same category.

Filter products by:
- availability
- price advantage
- higher quantity
- active offers
- better margin
- sponsored campaign eligibility

Rank products and show the best swap option.

A simplified version may look like this:

cart_swap_score =
    similarity_score
  + price_value_score
  + availability_score
  + margin_score
  + sponsored_score

This is why the cart page is not passive anymore.
It is becoming an active recommendation surface.

6. Recommendation System

Quick commerce apps also use recommendation systems.

Examples:

Users who bought milk also bought bread.
Users who bought pasta also bought pasta sauce.
Users who bought chips also bought cold drinks.

These recommendations can also include sponsored products.
For example:

Frequently bought together:
- Nachos
- Salsa dip
- Sponsored soft drink

This creates another place where ads can be inserted naturally.

7. Analytics Pipeline

Brands do not only want ad impressions.
They want performance data.

They want to know:

How many users saw the ad?
How many clicked?
How many added the product to cart?
How many swapped?
How many purchased?
Which city performed best?
Which keyword converted best?
What was the return on ad spend?

So the platform needs an analytics pipeline.

A simplified event flow may look like this:

User opens app
   ↓
Homepage viewed
   ↓
Video ad impression logged
   ↓
Search event generated
   ↓
Sponsored product impression logged
   ↓
Product click logged
   ↓
Add to cart logged
   ↓
Swap suggestion shown
   ↓
Swap accepted or ignored
   ↓
Purchase completed
   ↓
Dashboard updated for brand

This is why event tracking is very important.
Without tracking, the platform cannot prove that ads are working.

Final Thought

Quick commerce may look like a delivery business on the surface.

But from a system design perspective, it is also a real-time search, ranking, recommendation, inventory, cart optimization, and advertising platform.

The user opens the app to buy something quickly.
The brand wants visibility at that exact moment.
The platform sits in the middle and controls what the user sees.

That attention is valuable.

And monetizing that attention through ads is one of the most interesting parts of the quick commerce business model.

So the next time you open Instamart or Zepto and see a swap suggestion in the cart, a sponsored product, or a small floating video ad on the homepage, remember:

Behind that small UI element, there may be an entire ad-serving and recommendation system running in real time.

An Interviewer Asked Me How Amazon Recommends Products Without Login

Anita Kapal — Sat, 27 Jun 2026 08:04:59 +0000

Recently in an interview I was asked one interesting question:

How does a platform like Amazon recommend products to user when user is not logged in?

I answered something like:
Amazon can use cookies to identify user and also when users search for products Amazon saves that information in key-value format like this product is searched by many users and recommends based on that

After the interview, I kept thinking about it my answer was not completely wrong but I felt that the interviewer was expecting something more. So I searched for it and learned more about it. This is how I will answer the same question now.

My Original Answer

Even if the user is not logged in, Amazon can store an anonymous user in this browser using cookies or local storage.
For example:
anonymous_user_abc123 searched "wireless mouse" anonymous_user_abc123 viewed "Logitech

yes cookies or session IDs are part of the answer, but the more important question is:
After identifying an anonymous session, how amazon decide what to recommend?

What I Missed

A better answer should include these parts:

Anonymous user tracking
Session-based behaviour
Item-to-item recommendations
Merging anonymous activity after user login

Let me explain each one
1. Anonymous User Tracking
Even without login Amazon can create a temporary anonymous profile based on:
cookie ID
session ID
device/browser information
IP-level location
current browsing history

For example if i open Amazon and search for "running shoes" then click on some few products like Nike and Adidas shoes, Amazon can understand this anonymous user session is interested in running shoes related products.
So the system will build a short-term profile like:

anonymous_user_abc123: interested_categories: shoes, fitness searched_terms: running shoes viewed_products: Nike shoes, Adidas shoes possible_intent: buying sports shoes

This profile is temporary, but it is still useful

2. Session-Based Recommendations

For a user who is not logged in, Amazon will be depend on the current session. That means latest user actions become very important.

For example:
User searches: "iPhone 15 case"
User views: transparent iPhone case

Now Amazon can recommend products:
MagSafe charger
screen protector
phone stand

This is called session based recommendation system does not know the user but based on what this session is doing right now, these products are more relevent.

3. Item-to-Item Recomendations

This is probably the most important thing I missed in my interview answer. Amazon does not always need a full user profile to recommend products. Sometimes, the current product itself is enough.

For example, if a user is viewing an iPhone, Amazon can recommend:
iPhone case
screen protector
charger

Why?
Because many users who viewed or bought an iPhone also bought these related products. This is understood as item-to-item collaborative filtering. Instead of asking "What does this user like?" System asks, " What products are related to the product this user is currently viewing?"
So even if the user is anonymous, Amazon can still recommend products based on product relationships.

This is where my original answer was weak.
I said this product has been searched by many users. But a better answer to say is: Amazon can use aggregate behavior from many users to build relationships between products, such as "frequently bought together," "customers also viewed," and "similar products."

4. What Happens After Login?
One good point to mention in an interview is profile merging.
Later, when the user logs in, Now Amazon may connect that anonymous session activity with the logged-in account. So the temporary anonymous behavior can become part of the user’s long-term recommendation profile.
This is useful because the system does not lose the user’s intent just because they started browsing before login

Final Learning

The main thing I learned from this interview question is that in system design or backend interviews, we should not stop at one keyword.

Saying "cookies" was not wrong, but it was incomplete.

A better answer connects multiple parts:
anonymous identification
event tracking
session behavior
item similarity
profile merging

This question also taught me that recommendation systems do not always need a logged-in user.
A lot can be done using the current session and aggregate behavior from other users.

So next time, instead of answering only from the storage perspective, I will answer from the complete system perspective.
And that is the difference between a partially correct answer and a strong interview answer.