The SmallcapShop Strategy: When NiftyShop Meets Smallcap Universe

If you’ve been following my earlier posts or videos, you probably remember the NiftyShop and MidcapShop strategies — simple, rule-based swing trading systems designed for people who don’t have the luxury of staring at screens all day.

Now, what if we took that same logic… and applied it to the NSE Smallcap 50 stocks?
That’s exactly what I did — and the results were, honestly, quite surprising.

Why Smallcaps?

Let’s start with the “why.”

The original NiftyShop strategy was built around the Nifty 50 — India’s top large-cap stocks. The system was elegant and disciplined, but it had one major criticism: capital often sat idle for long stretches. Large caps move slowly; they’re stable, but they don’t rotate positions very fast.

That’s when a fellow community member, Vijayanand Mishra, suggested —

“What if we applied the same logic to the Midcap 50 stocks?”

It was a simple yet smart thought — midcaps generally have more momentum than large caps, which means faster rotation, better fund utilization, and potentially higher returns.

The MidcapShop tests confirmed that hunch beautifully.
But once we saw that improvement, the next question was obvious —

👉 Can we push it one step further with the Smallcap 50 universe?

The Core Strategy Logic

The SmallcapShop Strategy is built on the same backbone as the NiftyShop and MidcapShop variants.
It’s a long-only swing strategy on the daily timeframe, and it takes barely 10 minutes a day to manage — perfect for working professionals.

Here’s how it works in simple terms:

Entry Rules

1. Every evening, calculate each stock’s distance from its 20-day moving average (20DMA).
2. Find the top 5 stocks that are farthest below their 20DMA — in percentage terms.
3. Start from the top of that list and buy the first one that’s not already in your portfolio.
4. If all 5 are already in holding, enter averaging mode.
5. In averaging mode, look for stocks in your holdings that have fallen more than 3% from the last buy price — and add to those positions.

Exit Rules

• Exit when the stock hits 5% profit from your average buy price.
• Exits are checked first, then new buys are made — so freed-up capital can be reused the same day.

Capital Management

Capital allocation is where things get interesting.

In my backtests, I experimented with three different position sizing methods:

1. Static allocation: Fixed amount per trade (₹10,000 or ₹20,000).
2. Dynamic allocation: A percentage of available cash (1.5%–2.5%).
3. Divisor model: Total portfolio value divided by a divisor (10, 20, 30, or 40) to get position size.

Each method tells a slightly different story — static is simple, dynamic adjusts with cash, and the divisor model scales naturally with portfolio growth.

This flexibility is what makes the backtester powerful — you can simulate all these modes automatically and compare performance.

The Results

Test Period : 1/Jan/2020 to 30/Aug/2025

Without revealing too many spoilers (I’ve uploaded the detailed reports and Python code in the community store), the key takeaway is this:

The SmallcapShop variant performed exceptionally well, showing strong rotation, higher fund utilization, and smoother equity curves than its large-cap cousin.

It’s not about hitting astronomical returns — it’s about maintaining steady compounding with minimal effort.
The XIRR for the best configuration came in around 48%, which, for a simple 10-minute-a-day swing strategy, is remarkable.

For the Community

To help others explore this further, I’ve packaged everything into a Community Shop resource. You can find mroe details on the backtest results as part of this resource:

• ✅ Full Python backtest code
• ✅ Trade logs (CSV) - Bullish and Bearish Variations
• ✅ A full Strategy Performance Metric Report with Equity Curve, drawdown, XIRR, CAGR, Fund Utilisation, Monthly returns heatmap and a year-on-year report on whether the strategy exceed benchmark returns

You can grab it here → [Community Shop Link]

How I Backtested This

I have a full-fledged backtesting framework in Python, built to test trading strategies with precision.