QuantForge

FVG Profile + Rolling POC [BigBeluga] – Fair Value Gap Heatmap with Delta Volume

FVG Profile + Rolling POC [BigBeluga] – Fair Value Gap Heatmap with Delta Volume

Key takeaways

  1. Visualize where Fair Value Gaps cluster across price levels with a directional histogram showing bullish and bearish gap density
  2. Track the Rolling POC line as a dynamic support/resistance level that shifts only when the underlying gap structure changes
  3. Use per-bin delta volume to separate genuinely contested price zones from one-sided imbalance areas in your algo strategy
  4. Run it locally with PineTS on Node.js for backtesting or real-time signal generation via the Binance data provider

Loading chartโ€ฆ

Indicator Credits : Author : BigBeluga

What Is FVG Profile + Rolling POC?

You know how traditional volume profiles show you where trading activity clustered? BigBeluga’s FVG Profile takes that same concept and applies it to Fair Value Gaps instead. Rather than counting traded volume at each price level, this indicator counts how many bullish and bearish FVGs formed near each zone over a configurable lookback window. The result is a horizontal histogram that tells you exactly where price inefficiencies keep stacking up.

What really sets this apart is the Rolling POC (Point of Control) line. Unlike a static profile that only shows the final snapshot, the POC recalculates on every bar, tracking the price level with the densest FVG activity as it moves through time. Pair that with per-bin delta volume (bullish FVG volume minus bearish FVG volume) and you get a surprisingly complete picture of where the market’s structural imbalances live. I’ve been running this on weekly BTCUSDC charts and the POC line acts like a magnet for price reactions.

Running FVG Profile with PineTS

PineTS transpiles Pine Script to JavaScript and runs it locally against real market data. Skip the TradingView subscription; you’re pulling directly from Binance. Here’s the setup.

Installing PineTS

Grab PineTS from npm:

npm install pinets

Loading the Pine Script Indicator

You give PineTS a source file, a ticker, a timeframe, and a bar count. It handles transpilation and pulls the data from Binance. For this indicator, go with at least 500 bars; that’s what the default lookback expects.

Method 1: Batch Execution with pineTS.run()

The batch approach downloads historical data, runs the full indicator calculation in one pass, and gives you the complete context object with all plot values. Perfect for backtesting or one-off analysis.

// PineTS batch execution example template
import { PineTS, Provider } from 'pinets'
import { readFileSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'

const __dirname = dirname(fileURLToPath(import.meta.url))
const pineScript = readFileSync(join(__dirname, 'source.pine'), 'utf-8')

const pineTS = new PineTS(Provider.Binance, 'BTCUSDC', '1w', 500)
const ctx = await pineTS.run(pineScript)

console.log('Bars processed:', ctx.marketData.length)
console.log('Plots:', Object.keys(ctx.plots).join(', '))

for (const [name, plot] of Object.entries(ctx.plots)) {
  const lastPoint = plot.data?.[plot.data.length - 1]
  if (lastPoint) {
    console.log(`  ${name}: last value = ${lastPoint.value}`)
  }
}

After it runs, ctx.plots gives you the full time series for every named plot. Pull the Rolling POC by bar index to feed the level directly into your signal logic. The MA plot comes along for free if you have it enabled.

Method 2: Live Streaming with pineTS.stream()

If you want the indicator to update in real time as new candles close, the streaming API is your friend. It reconnects to the Binance WebSocket feed and re-evaluates the full Pine Script on every tick.

Inputs

Main Settings

InputTypeDefaultDescription
Lookback Periodint500Number of bars to scan for FVGs
Profile Resolution (Bins)int40Number of horizontal price rows in the profile
Horizontal Offsetint10Shifts the profile rightward to avoid overlapping candles

Display Toggles

InputTypeDefaultDescription
Show Fair Value GapsbooltrueDraws individual FVG boxes on the chart
Show Strength PercentagebooltrueDisplays percentage labels per bin
Show Rolling POC LinebooltrueEnables the dynamic Point of Control line
Show Delta VolumebooltrueShows bull minus bear FVG volume per bin
Show Bull / Bear FVG CountbooltrueLabels each bin with bullish and bearish gap counts
Enable HeatmapboolfalseOverlays a gradient showing gap density across the range

Colors

InputTypeDefaultDescription
Bullish/Bearish Colorcolor pairlime / orangeColors for bullish and bearish profile segments
Background Colorcolorgray (80% transparent)Profile area background
POC Colorcolorrgb(255, 102, 0)Rolling POC line color

Moving Average

InputTypeDefaultDescription
TypestringNoneMA type: None, SMA, EMA, SMMA (RMA), WMA, VWMA
Lengthint25MA period (ignored when Auto is enabled)
AutoboolfalseAutomatically scales MA length to the lookback period
SourcesourceclosePrice source for the moving average

Plots

Plot NameTypeDescription
Rolling POCLine (linebr)SMA-smoothed (10-period) rolling Point of Control tracking peak FVG activity
MALine (linebr)Configurable moving average overlay (disabled by default)

Alerts

This indicator does not define alert conditions.

Understanding the Indicator

FVG Detection and Binning

The core mechanic is straightforward. A bullish FVG fires when high[i+2] < low[i], meaning two bars ago’s high is strictly below the current bar’s low, leaving a gap. Bearish FVG is the mirror: low[i+2] > high[i]. Nothing exotic, just classic three-bar gap detection.

Where it gets interesting is how BigBeluga handles the binning. The full price range across the lookback (default 500 bars) gets sliced into 40 horizontal bins. Each FVG’s midpoint (math.avg(high[i+2], low[i]) for bullish, inverse for bearish) gets mapped to its nearest bin. The script then increments both a gap count and a volume accumulator for that bin. So you end up with two parallel arrays per direction: how many FVGs hit that price zone, and how much volume was associated with the bar where each FVG formed.

Smart design choice. By using the midpoint of the gap rather than one edge, you get a more stable bin assignment that doesn’t flip based on whether the gap was barely touching a boundary.

The Rolling POC: Why It Matters

The static profile (rendered on the last bar) is useful, but the real gem is the get_poc() function that runs on every bar. It performs the same FVG detection and binning, but only cares about finding the single bin with the highest total count. That becomes the Point of Control for that bar.

The raw POC value gets smoothed with a 10-period SMA via ta.sma(rollingPoc, 10). This prevents the line from jumping erratically when a single new FVG enters or exits the lookback window. On BTCUSDC weekly, that smoothing creates a flowing level that price respects surprisingly well as dynamic support and resistance.

One thing to keep in mind: the POC loop iterates through all 500 bars on every single bar calculation. That’s a nested loop (500 bars times 40 bins for the profile), so on very low timeframes with large lookbacks you might notice some computation lag. On weekly or daily charts, it’s not a problem at all.

Delta Volume and Directional Bias

Look, counting FVGs is nice, but the delta volume feature is what turns this from a visualization into an actual trading tool. For each bin, the script calculates bullVol.get(k) - bearVol.get(k). Positive delta means bullish FVGs at that level carried more volume. Negative means bears dominated.

Not all gaps are created equal, though. A price zone with 8 bullish FVGs and 2 bearish FVGs might look strongly bullish in the count profile, but if those 2 bearish FVGs happened during massive sell-off candles, the delta volume flips the story entirely. The profile labels color-code by delta direction (green for bullish dominance, orange for bearish), so you can see this at a glance.

I find the combination of count and delta volume particularly useful near range boundaries. When you see a bin with high total gap count but near-zero delta, that’s a genuinely contested zone. When count and delta align strongly, it’s a one-sided magnet.

Using It for Algorithmic Signal Generation

Here’s where it gets practical for bot builders. The Rolling POC line is your primary signal. When price crosses above the POC, you’re moving away from the densest cluster of historical inefficiency, which often signals a breakout. When price gravitates back toward it, you’re entering a high-probability reaction zone.

I’ve been testing a simple approach: go long when price closes above the Rolling POC on a weekly candle and the most recent FVG at the POC level had positive delta volume. Exit when price closes below. It’s crude, but on trending pairs it actually filters out a lot of noise.

If you want to go deeper: pull the relative strength percentage for each bin. Bins over 50% with positive delta are where buyers kept showing up. Bins over 50% with negative delta are where sellers were. Stack those as levels in a grid bot instead of using fixed spacing, and the grid adapts to where the market’s actually been fighting.

The optional MA overlay helps confirm trend direction. With the “Auto” length feature enabled, the MA period scales automatically with your lookback, which means you don’t need to manually tune it when you change timeframes. That’s a nice quality-of-life touch for multi-timeframe scanning.

Performance Notes

No repainting. The Rolling POC is a historical calculation, the SMA is a straight lookback, and FVG detection requires the bar after the gap to confirm. So you’re always working with a 1-bar lag. That’s the correct behavior, not a bug.

The main performance consideration is the nested loop inside get_poc(). With the default 500-bar lookback and 40 bins, you’re running 20,000 iterations per bar. On weekly charts that’s barely noticeable. On 1-minute charts with 500 bars of lookback, expect some slowdown during the initial load. If you’re using PineTS in a production bot on low timeframes, consider dropping the lookback to 200 or reducing the bin count to 20.

The calc_bars_count = 5000 and max_bars_back = 5000 settings in the indicator declaration mean PineTS needs to fetch enough historical data to cover the lookback window plus warmup. With the default 500-bar lookback on a weekly chart, that’s about 10 years of data. Binance covers BTC pairs comfortably at that depth.

Important Notes

PineTS successfully compiles and executes this indicator (Pine v6). The Rolling POC and MA plots render correctly in both batch and streaming modes. The static profile (box drawings, labels, and heatmap) are visual elements that render on TradingView’s chart canvas only. In PineTS, you get the plot values (POC line, MA line) as numerical time series, exactly what you need for algo integration.

The indicator uses the Binance data provider by default. Since FVG detection depends on gap formation between candles, you’ll see different results on assets and timeframes where gaps are rare (like forex on lower timeframes). Crypto markets with 24/7 trading and volatile sessions produce the most FVGs, making this indicator particularly well-suited for digital assets.

One limitation to be aware of: the volume used in delta calculations comes from the bar where the FVG formed, not from subsequent volume that traded within the gap. This is a common simplification in FVG-based tools, but it means the “delta volume” is really “delta formation volume.” Keep that in mind when interpreting the directional bias at each level.

Disclaimer

QuantForge publishes technical material about indicators: what they do, how they are built, and how you can experiment with them in code and on charts. All of this is offered for education and illustration only. It is not financial, investment, or trading advice, and it should not be read as a recommendation to buy, sell, or hold any asset. Past or simulated performance does not guarantee future results. You are responsible for your own decisions; seek independent professional advice where appropriate.