Stock Screener & Pine Script Editor

The Bottom Menu is a collapsible strip beneath the chart canvas. Clicking a tab label expands it upward over the chart; dragging its top edge resizes it. Clicking the active label again collapses it, which matters during a live NSE session when you want the full canvas back quickly.

Each tab is a separate engine rather than a different view of the same thing. The Screener answers 'which instruments currently match these conditions'. The Pine Editor is where you write code. The Strategy Tester reports what a coded rule would have done historically. The Trading Panel places orders, simulated or real.

The Screener is the discovery layer. It reads a large table of instruments and filters it by fields you choose — exchange, market capitalisation, valuation ratios, price relative to a moving average, volume. Its job is to hand you twenty names instead of two thousand, at which point actual chart work begins.

The Pine Editor exists because dropdown filters run out. TradingView's built-in filters cover common conditions; anything with a sequence in it — 'this happened, and then that happened within five candles' — needs to be written out. Pine Script is the language you write it in, and it runs on TradingView's servers rather than your machine.

The Strategy Tester activates only when a script is declared as a strategy rather than an indicator. It walks through historical candles executing the script's rules and reports what that rule set would have produced on that data. It is a report about the past, and the article below is careful about what that can and cannot tell you.

The Trading Panel connects to a broker or to the paper-trading simulator, so orders can be placed from the same screen the analysis lives on. Nothing about that connection changes the analysis — it removes a context switch, which is a workflow benefit rather than an analytical one.

Open the Stock Screener tab and the first thing to do is set the exchange. With Exchange set to NSE, the table becomes the Indian listed universe — roughly two thousand names, which is far more than anyone can look at. Every filter after this one exists to make that number smaller.

Market capitalisation is the most effective first cut. Market cap is simply share price multiplied by the number of shares outstanding — the total rupee value the market places on the company. Setting a floor at, say, ₹10,000 crore removes the illiquid end of the list, where a single order can move the price and where chart structure is often meaningless.

Liquidity deserves its own filter alongside it. Average volume over 30 days tells you how many shares change hands on a normal day. A stock whose average is 20,000 shares cannot absorb a meaningful position without slippage — the gap between the price you expected and the price you actually got, caused by there being too few resting orders at your level.

Now the fundamental fields, each of which is worth defining. P/E, the price-to-earnings ratio, is the share price divided by earnings per share; it says how many rupees the market pays for one rupee of annual profit. EPS, earnings per share, is net profit divided by shares outstanding. ROE, return on equity, is net profit as a percentage of shareholder funds — how efficiently the company turns owners' capital into profit.

EV/EBITDA is the one people skip and shouldn't. Enterprise value is market cap plus debt minus cash — what it would cost to buy the whole business including its obligations. EBITDA is earnings before interest, tax, depreciation and amortisation, a rough proxy for operating cash generation. The ratio compares the two, and unlike P/E it is not distorted by how much debt a company carries.

The technical fields carry their own vocabulary. RSI, the relative strength index, is a 0-to-100 oscillator measuring the size of recent gains against recent losses. MACD, moving average convergence divergence, tracks the gap between two exponential moving averages. ATR, average true range, measures a typical candle's full range over a lookback and is a volatility measure rather than a direction one.

A worked screen: Exchange = NSE, market cap above ₹10,000 crore, 30-day average volume above 5 lakh shares, price above the 200-day simple moving average, and price within 15% of its 52-week high. That is a description of large, liquid names holding a long-term uptrend — a starting list for chart work, not a list of trades.

Everything the screener returns is a starting point. A filter combination describes a state a stock is in today; it says nothing about what happens next, and no arrangement of filters converts a list into a decision. The chart work after the screen is where the actual analysis happens.

Screening for the Indian market has three practical layers, and only some of them live inside TradingView. Being clear about which is which saves a lot of wasted searching through filter menus.

The first layer is capitalisation banding, and it is entirely native. NSE and index providers segment the market into large-cap, mid-cap and small-cap bands. In the screener you approximate these with market-cap floors and ceilings — for example above ₹50,000 crore for the large-cap end, ₹15,000 to ₹50,000 crore for the middle, and below that for small-caps.

Why band at all? Because the same setup means different things in different bands. A base breaking out on NSE:RELIANCE happens in a name with deep resting liquidity on both sides. The same visual pattern on a ₹800-crore small-cap can be a handful of orders. Banding first stops you comparing structures that are not comparable.

The second layer is delivery percentage, and here you need to know the limitation. Delivery percentage is the share of a day's traded volume that actually settled as delivery into demat accounts, rather than being squared off intraday. A high figure means buyers took the stock home; a low figure means the day's volume was largely intraday churn.

TradingView's stock screener does not carry a delivery-percentage field. The data is published by NSE itself in its daily security-wise delivery position, so if you want to use it you bring it in from there and apply it as a second pass on the shortlist the screener produced. Treat this as a manual step, not a filter you will find in a dropdown.

The third layer is derivatives eligibility. Only a defined list of securities has futures and options available on NSE, and that list is maintained and revised by the exchange. Whether a stock is F&O-eligible changes what you can do with it and how it tends to behave around expiry.

The workable approach is a watchlist. Take NSE's published list of derivative-eligible securities, build it as a TradingView watchlist, and run your screening within that list rather than trying to express eligibility as a filter. The Pine Screener, covered later, runs against a watchlist by design, which makes this the natural pairing.

Put together, the Indian workflow reads: set the exchange, band by market cap, filter for liquidity, apply your technical and fundamental conditions, then cross-check the survivors against the derivatives list and — if you use it — the exchange's delivery data. What comes out is a shortlist to study, and studying it is a separate job from producing it.

TradingView runs separate screener engines per asset class, because the fields that describe a stock do not describe a bond or a token. Each engine carries the vocabulary of its own market rather than forcing everything into equity language.

The stock screener is the one Indian traders use most, and it covers NSE and BSE listings alongside global exchanges. Its fields split into the fundamental group (valuation, profitability, balance sheet) and the technical group (price relative to moving averages, volume, range measures).

The ETF screener describes funds rather than companies, so its fields are assets under management, expense ratio and tracking performance rather than P/E and ROE. The bond screener works in yield, maturity and credit rating — again, a completely different vocabulary because a bondholder is asking a different question from a shareholder.

The crypto screeners carry fields with no equity analogue at all: circulating supply, 24-hour volume across venues, and market dominance. Two separate engines exist for exchanges — one for centralised venues and one for decentralised ones, where liquidity-pool metrics replace conventional order-book data.

The Pine Screener is the odd one out and the most useful once you outgrow dropdowns. Rather than filtering a table, it runs a Pine Script you wrote against every symbol in a watchlist and returns those that satisfy the script's conditions. That is what makes it the right home for the NSE derivatives-eligible watchlist described earlier.

One habit is worth forming immediately: save filter combinations as presets. A preset called 'NSE large-cap liquid' holding your exchange, market-cap and average-volume settings means the daily routine starts from a clean base rather than from re-entering the same four filters every morning before 09:15 IST.

A screener returns a list; a heatmap returns a picture. Every stock in a market is drawn as a rectangle, sized by market capitalisation and coloured by performance over the period you select — green for gains, red for losses, with deeper colour meaning a larger move.

The sizing is the part that makes it informative rather than decorative. Because rectangles are scaled by market cap, a small green square in a corner is a small company having a good day, while a large red block in the centre is a heavyweight dragging the index. A simple gainers list treats those two identically; the heatmap does not.

The grouping does the rest of the work. Stocks are clustered by sector and then by industry, so a block of colour is immediately readable as a sector-wide move rather than a stock-specific one. If the IT cluster is uniformly green while banking is uniformly red on the same day, that is a rotation you can see without opening a single chart.

That distinction matters for what you do next. A single green name inside an otherwise red sector is a company-specific story — results, an order win, something in its own filings. A uniformly green sector is a flow story, and the individual chart you were about to study may simply be carrying its sector rather than doing anything of its own.

For Indian markets, filter by country India and then by sector to work through the NSE landscape a segment at a time. Combined with the timeframe toggle — one day, one week, one month, year-to-date and one year — you can see whether today's colour agrees with the last month's or contradicts it.

A useful pre-session habit: look at the one-day and one-month views side by side. Where they agree, the sector has been moving in one direction consistently. Where they disagree, something changed recently, and that is worth understanding before you take a position in a name inside that block.

The Pine Script Editor is TradingView's coding environment for Pine Script v6, a language built specifically for market data. Unlike a general-purpose language, its data types and functions assume you are working with price series, volume and time — a variable in Pine is usually a whole series of values, one per candle, rather than a single number.

That single design decision is why Pine is learnable without a programming background. Writing `close > ta.sma(close, 200)` compares every candle's close against its own 200-period simple moving average across the entire chart at once. There is no loop to write and no array to manage; the series handling is the language's job.

The editor lives in the bottom panel and provides the usual conveniences — syntax highlighting, autocomplete across the built-in namespaces such as `ta.` for technical functions and `strategy.` for order simulation, error diagnostics before compilation, and `log.info()` for printing values while a script runs so you can see what it actually computed.

The most underrated learning route sits on your chart already. Click the `{}` icon next to any built-in indicator's name and its complete Pine source opens in the editor. Reading how the platform's own moving averages, bands and oscillators are constructed teaches more in an hour than most tutorials, because the code is short and the output is on screen beside it.

Four things can be built. An `indicator()` draws on the chart and nothing else. A `strategy()` can simulate orders and therefore activates the Strategy Tester. A library is a set of reusable functions other scripts can import. A Pine Screener script encodes conditions to be run across a watchlist rather than one symbol.

Start by modifying rather than authoring. Open a built-in indicator's source, change a lookback length, add a plot, and watch the chart respond. The gap between reading code and writing it closes fastest when the feedback is immediate and visible, which is exactly what this environment provides.

Dropdown filters describe states, not sequences. They can tell you that RSI is currently between 50 and 60, but not that a moving-average cross happened and then price held above the faster average for the next five candles. Sequences need code.

The Pine Screener closes that gap. You write an indicator that evaluates your condition to true or false on the latest candle, save it to your favourites, open the Pine Screener, point it at a watchlist, and click Scan. It runs your script against every symbol in that list and returns those where the condition is currently true.

This is where the NSE derivatives-eligible watchlist earns its keep. Build the exchange's list once, then any screening rule you write can be pointed at that universe in a click, without trying to express eligibility as a filter that does not exist.

The constraints are real and worth knowing before you design around them. Lookback is limited, `request.*` functions for pulling other symbols or timeframes are restricted, the script must be saved to favourites before it appears in the menu, and results are produced when you click Scan rather than streaming continuously.

Declare a script with `strategy()` instead of `indicator()` and the Strategy Tester tab comes alive. It walks through the chart's historical candles executing your rules as simulated orders, then reports what that rule set would have produced on that specific data.

The report has four sub-tabs: an overview of headline figures, a performance summary splitting long from short, a chronological list of every simulated trade with its timestamps, and an equity curve plotting the simulated account balance through time.

Now the vocabulary, because these terms are used constantly and rarely defined. Profit factor is gross gains divided by gross losses across the simulated trades — at 1.0 the two cancel exactly. Maximum drawdown is the largest peak-to-trough fall in that simulated equity curve, expressed as a percentage of the peak.

Sharpe ratio is a risk-adjusted measure: it divides the simulated return above a risk-free rate by the volatility of those returns. Two rule sets producing the same result, one smoothly and one through violent swings, will differ sharply here — the volatile one scores lower, which is the point of the measure.

Slippage and commission are inputs you must set yourself, and leaving them at zero is the most common way a test flatters a rule. Slippage is the difference between the price a rule assumed and the price the market would actually have given; commission is brokerage and charges. A frequently trading rule can look entirely different once both are entered honestly.

The framing that matters most: these are descriptions of what a rule did on one historical sample, not properties of the rule. Historical results carry no promise about future behaviour, and a report describing past candles is evidence about those candles alone. Read the metrics as diagnostics for improving the logic, never as an expectation of what the rule will produce.

Used that way, the panel is genuinely useful. A rule with a smooth equity curve and a shallow drawdown is behaving consistently across the sample; one with a jagged curve dominated by two large trades is telling you the result came from a handful of candles and would vanish if those candles were removed. That is the kind of question the tester answers well.

The Chart Range selector along the bottom edge holds zoom presets — 1D, 5D, 1M, 3M, 6M, YTD, 1Y, 5Y and All — that snap the visible window to that period in one click, without dragging the time axis around.

Go to Date, on Alt+G for Windows or Option+G on Mac, opens a calendar and jumps the chart to any date in history. This is how you study a specific session rather than scrolling towards it: type the date of a Union Budget, an RBI policy announcement or a results day and land on that candle directly.

The reason to do this deliberately is that event candles distort structure. A gap created by a results announcement on NSE:INFY is not the same kind of level as a base built over thirty candles of ordinary trade, and knowing which you are looking at changes how much weight the level deserves.

Pairing it with Bar Replay is the strongest study routine available on the platform. Jump to a date, start replay from that candle, and step forward one bar at a time so the outcome is not visible while you form a read — which is the only honest way to practise on data that has already happened.