Custom Pine Script development for TradingView — indicators, strategies, and alert scripts built to your specification in Pine Script v5. Fixed-price quotes within 48 hours. You own the source code outright.
What You Get
- Pine Script v5 source code delivered as a `.pine` file — paste directly into TradingView’s Pine Editor
- Full ownership — no licensing restrictions, no recurring fees, no vendor lock-in
- Alert conditions included and compatible with TradingView webhooks for external execution pipelines
- Support window post-delivery for adjustments, edge-case fixes, or input parameter changes
- Implementation notes explaining how the script works and how to configure it for your instruments
How It Works
- Specify your logic — describe the indicator rules, visual output, inputs, alert conditions, and any reference scripts you are working from
- Quote within 48 hours — we review the specification and deliver a fixed price. No hourly billing, no surprises
- Build in Pine Script v5 — development with testing across multiple instruments and timeframes before delivery
- Receive source code — you paste the `.pine` file into TradingView’s Pine Editor. It is ready to use on any chart
Who This Is For
Good fit:
- Traders who live on TradingView and need a custom indicator that does not exist in the public library
- Traders migrating from MetaTrader who want to recreate their indicator logic on TradingView for chart analysis
- Anyone who attempted to write Pine Script themselves and hit the limits of v5’s series-based execution model — multi-timeframe lookups, confirmed-bar conditions, or complex alert logic
- Traders who need a strategy script for TradingView’s built-in backtester to validate entry and exit rules
Not the best fit:
- Projects where the primary goal is fully automated live execution without any broker integration — Pine Script cannot place orders directly. See FAQ below
- Projects under $100 — TradingView’s free public indicator library covers most simple single-calculation use cases
What Makes This Different
The most common failure mode in Pine Script work hired online is repainting — an indicator that shows clean signals on historical bars but changes its output as new bars form in real time. The cause is almost always a `request.security()` call accessing higher-timeframe data with `lookahead=barmerge.lookahead_on`, or logic evaluated on an incomplete (open) bar without `barstate.isconfirmed` as a gate. Both issues pass every visual check on a historical chart. They only reveal themselves in live use, when the signals you acted on yesterday no longer match what the chart shows today.
Every indicator and strategy delivered from this service uses confirmed-bar logic by default. When lookahead is intentionally required for a specific use case — for example, historical analysis tools where the bar is never re-evaluated — it is explicitly documented so you know exactly what you have.
Multi-timeframe (MTF) analysis is the other area where Pine Script work frequently breaks in production. TradingView imposes limits on the number of `request.security()` calls per script, and the order in which higher-timeframe values are evaluated affects accuracy at intraday resolution. These constraints are not well-documented. They appear as stale MTF values, wrong bar counts, or inconsistent results depending on the chart timeframe — problems that only surface under specific conditions that casual testing misses.
I have been building algorithmic trading tools since 2011, primarily for MetaTrader. TradingView’s Pine Script uses a fundamentally different execution model — series-based, interpreted, with no event-driven callbacks. When traders ask me to convert their existing MT4 indicators to Pine Script, the translation is usually straightforward for the calculation logic. Where it gets technical is matching the execution behavior across platforms. That is the part that experience covers.
Pricing
Simple indicators — single calculation, basic visual output, up to 3 configurable inputs — start at $150.
Standard indicators with multi-timeframe support, advanced visual formatting, conditional logic across multiple data sources, or alert conditions with webhook compatibility typically range from $200 to $600.
Full strategy development with backtesting configuration, commission and slippage settings, and alert integration for external execution pipelines typically ranges from $400 to $1,200 depending on scope and complexity.
Fixed-price quote within 48 hours. No hourly billing. Source code delivered — you own it outright.
Frequently Asked Questions
How much does a Pine Script developer charge?
Simple custom indicators start at $150. Standard indicators with multi-timeframe logic, alert conditions, or specific visual requirements typically fall between $200 and $600. Full strategies with backtesting configuration and webhook alert integration range from $400 to $1,200 depending on scope.
At barmenteros FX, every project starts with a fixed-price quote based on your specification — delivered within 48 hours. No hourly billing, no retainer, no ongoing fees. If the scope changes after the quote, we agree a new price before any additional work begins.
Can Pine Script strategies be used for live trading?
Not directly. TradingView strategies display backtested results in the built-in Strategy Tester — they do not route live orders to a broker on their own.
To execute orders from a Pine Script strategy, you need one of two setups: a broker account with native TradingView integration (a limited list that includes OANDA, Alpaca, and futures brokers via AMP Futures or TradeStation) or a webhook alert pipeline where the strategy fires an alert on a signal condition and an external service (such as 3Commas, Autoview, or a custom webhook handler) receives that alert and places the order.
If fully automated live execution is the primary goal — without the overhead of a webhook pipeline — MetaTrader 4 or 5 with an MQL4/MQL5 Expert Advisor is a more direct architecture. Both approaches are available through barmenteros FX depending on what your workflow requires.
What is the difference between a Pine Script indicator and a strategy?
A Pine Script indicator declared with `indicator()` plots visual information on a chart — lines, histogram bars, labels, background colors — and fires `alertcondition()` events. It has no position sizing, no P&L tracking, and no backtesting output.
A strategy declared with `strategy()` includes all indicator functionality plus `strategy.entry()` and `strategy.exit()` calls that simulate trades in TradingView’s built-in Strategy Tester. This gives you an equity curve, drawdown figures, trade-by-trade logs, and net profit statistics.
Strategies are heavier scripts and are subject to calculation limits that indicators are not. They also cannot be added to a chart if you are on a TradingView plan that restricts access to the Strategy Tester. Check your plan before commissioning a strategy if budget is a constraint — the free plan does not support strategies on most timeframes.
How do you prevent repainting in Pine Script?
Repainting happens when a script produces signals on historical bars that are not visible in real time, or shows different values on a historical chart than it showed when those bars were live.
The most common cause: `request.security()` calls accessing a higher timeframe without `barstate.isconfirmed` as a condition, or with `lookahead=barmerge.lookahead_on`. The fix is to evaluate higher-timeframe values only on confirmed (closed) bars — either by gating the evaluation on `barstate.isconfirmed` or by referencing the previous bar’s confirmed value (`close[1]` at the higher timeframe rather than `close`).
A secondary cause is logic that uses `ta.highest()` or `ta.lowest()` over lookback windows that expand as new bars form, combined with `var` variable updates evaluated on real-time ticks rather than closed bars.
Both patterns are tested for before delivery. When confirmed-bar evaluation is intentional — for example, indicators designed for historical analysis — the behavior is documented explicitly so there is no ambiguity about how the script executes.
Can you convert an MT4 or MT5 indicator to TradingView Pine Script?
Yes. This is one of the more common project types — traders who have built or commissioned custom MetaTrader indicators and want to use the same logic on TradingView for chart analysis alongside their MT4/MT5 setup.
The core calculations usually translate directly: exponential moving averages, ATR, standard deviation bands, pivot calculations, custom oscillators. The main technical difference is execution model: MQL uses event-driven callbacks (`OnCalculate()` fires on each new tick or bar), while Pine Script evaluates top-down on every bar in the series from left to right. For most indicators, this difference is invisible in the output. Edge cases appear when the original MT4 indicator depends on tick-level data (which Pine Script cannot replicate at standard chart resolution) or uses `iCustom()` to call other indicators as inputs.
Any limitation that affects the conversion — precision loss, tick-data dependency, iCustom chains — is identified in the specification review and noted in the quote before work begins.