8.5 Trading Indicators — Thirteen Dedicated Lessons

Every indicator below is a different gauge on the same engine. None of them predict — they describe, faster or more clearly than raw candles. The rule of the module: two or three complementary gauges, maximum. A chart with nine indicators isn't analysis, it's a bird strike on a windscreen.

8.6 TradingView Masterclass

TradingView is the trader's workshop — charts, alerts, community scripts, backtesting and a full programming language, all in the browser. This module takes you from "just made an account" to "has a workspace that would make a fund manager nod slowly".

Creating an account & picking a plan

Sign up at tradingview.com. The free tier is genuinely enough to learn: full charting, 2 indicators per chart, limited alerts. Upgrade when — and only when — you hit a real wall (usually the indicator limit or wanting more alerts). Rule of the School: never pay to solve a problem you don't have yet.

Building layouts

1. One layout per job. A "Bias" layout (weekly + daily side by side), an "Execution" layout (4H + 1H + 15m), and a "Bots" layout for whatever your automation watches. Named, saved, separate.
2. Multi-chart sync: link charts by symbol so all panes follow the same coin, but keep timeframes independent. Instant multi-timeframe analysis (8.4 #12) on one screen.
3. Keep charts CLEAN. Price, volume, two or three indicators from your 8.5 stack, your marked levels. If your chart looks like a plate of party pies exploded, delete half of it.

Watchlists

Build three: Majors (BTC, ETH, the handful you actually trade), Radar (coins forming setups that aren't ready yet), and Zoo (everything else you're curious about — visited monthly, traded never... until it graduates to Radar with a real setup). Flag coins with coloured markers by setup type. Assignment 2 makes you build this properly.

Setting alerts — trade the plan, not the screen

Alerts are the single most underrated feature in trading. Instead of staring at charts (and inventing trades out of boredom — screens are pokies for traders), you mark your levels and let the phone buzz when price actually arrives.

• Right-click any price, trendline, or indicator → "Add alert". Alerts can trigger on crossings, closes, channel exits — and can fire webhooks, which is the doorway to automation in 8.7.
• Set alerts at your ZONES (where you'd consider acting), not at your entries. The alert wakes you up; the checklist (8.1) decides.
• Name alerts with instructions to your future self: "BTC at daily golden pocket — check 15m CHoCH before entry, min 1:2". Future-you at 3am is not smart. Leave him notes.

Templates

Save your indicator stack as a template ("Boganster Standard": your 8.5 three-gauge dashboard) and apply it to any chart in one click. Consistency between charts means your eye learns ONE visual language — pattern recognition compounds when the patterns always dress the same.

Pine Script basics

Pine Script is TradingView's built-in language. You don't need to be a programmer — v6 Pine reads close to English, and AI (8.8) will write most of it for you anyway. What matters is being able to READ it. A complete working indicator:

//@version=6
indicator("Boganster EMA Cross", overlay=true)

fast = ta.ema(close, 20)
slow = ta.ema(close, 50)

plot(fast, color=color.orange, title="Fast EMA")
plot(slow, color=color.blue,  title="Slow EMA")

bullCross = ta.crossover(fast, slow)
plotshape(bullCross, style=shape.triangleup,
     location=location.belowbar, color=color.green, size=size.small)

alertcondition(bullCross, "Bull Cross", "20 EMA crossed above 50 EMA — check the plan!")

That's a real, working indicator with a plotted signal and an alert hook. Change the numbers, change the coin, you've customised your first script. Every strategy in 8.4 with mechanical rules can be expressed this way.

Adding any script to your chart, step by step

This exact sequence works for the EMA Cross above, the SMC Liquidity Sweep Pro gift in 8.3, and any Pine script you ever copy from anywhere. Every step here has actually been run, including the one everybody trips on:

1. Open your chart at tradingview.com, then click Pine Editor in the bottom toolbar (same row as Strategy Tester). A code panel opens.
2. Create a blank script. Click the script name dropdown at the top of the panel → Create new → Blank indicator script. Don't paste into a script you already own — this makes a fresh one.
3. Clear the default template before pasting. TradingView pre-fills every new script with two starter lines (//@version=6 and plot(close)). Click into the code area, press Ctrl+A (Cmd+A on Mac) to select everything, and delete it. Skip this step and you'll hit "Scripts must contain one declaration statement" — a real error, not a hypothetical, because pasting your code underneath the leftover template gives Pine two competing declarations.
4. Paste the script — Ctrl+V — into the now-empty editor.
5. Let it compile. Watch the bottom-left status: it says "Compiling…" for a second, then either goes quiet (good) or shows a red error with a line number (fix and repeat). No red text means it's clean.
6. Click the ▷ play button next to the script name (or "Add to chart") to see it actually plot on the price chart.
7. Wire up alerts, if the script has any. Click Alert in the top toolbar → Condition → pick the script by name → choose the specific condition it offers (e.g. "Bull Cross", or "SMC BUY" / "SMC SELL" for the 8.3 gift) → set how you want to be notified.
8. Save it — Ctrl+S — and give it a name you'll recognise later.

Importing community indicators

The "Indicators" button → Community Scripts: a hundred thousand free indicators, including every SMC toy from 8.3 (order blocks, FVGs, liquidity levels — search and ye shall find). Two rules: check the open-source ones so you (or your AI) can read what they actually do, and remember the module rule — importing forty indicators is hoarding, not analysis.

Backtesting strategies

Pine strategy() scripts simulate your rules over history and produce a full report — net profit, win rate, max drawdown, profit factor. This is where strategies from 8.4 face the judge before real money does.

Replay mode — the flight simulator

Bar Replay rewinds the chart to any past date and plays it forward candle by candle, hiding the future. This is THE practice tool: pick a random month, trade your strategy through it with fake decisions and a real journal, and get a year of experience in a weekend. Twenty replay sessions before twenty paper trades before one real dollar — that's the Boganster pipeline.

8.7 Building Your Own Trading Bot

The summit of the course: turning your written, tested plan into software that executes it around the clock without emotions, bathroom breaks, or a sudden urge to "just check Twitter". A bot is your trading plan with the human removed — which is only an upgrade if the plan was good.

Introduction to APIs

An API (Application Programming Interface) is a service's tradie entrance — a way for programs to do everything you'd do by clicking, but by sending structured requests. Exchanges expose APIs for prices, balances, and orders. Your bot is just a loop: fetch data → apply YOUR rules → maybe place an order → log it → sleep → repeat. That's every trading bot ever built, including the fancy ones.

Exchange API keys — the safety rules (non-negotiable)

Python basics — the 10% you need

Python is the trading world's default language because it reads like instructions to an apprentice. You need: variables, if/else, loops, functions, and installing packages with pip. That's a weekend of learning, and AI (8.8) fills every gap. The essential toolkit:

• ccxt — one library that speaks to 100+ exchanges with the same commands. The Swiss Army knife.
• pandas — spreadsheets in code; holds and crunches your candle data.
• pandas-ta — every indicator from 8.5 as one-liners.

REST APIs vs WebSockets

TradingView webhooks — the shortcut bridge

The best-kept beginner secret: you don't need to code indicators in Python at all. Build the strategy in Pine (8.6), and have its alert fire a webhook — a message sent to a URL — at a tiny server you run (or a bot platform). TradingView does the analysis; your twenty-line receiver just places the order. Chart brain in Pine, order hands in Python. Beautiful division of labour.

Strategy automation, risk controls, logging

• Automate rules, not vibes. If a rule in your plan contains the word "feels", it can't be coded — which is the market's way of telling you it was never a rule.
• Hard-code the risk limits from 8.9: max position size, max daily loss (bot switches itself off), max open positions, and a "kill switch" you can hit from your phone. The bot must be MORE conservative than you, not less — it works nights, after all.
• Log everything: every decision (including "checked, did nothing"), every order, every error, with timestamps. When the bot does something weird at 3am — and one day it will — the log is the difference between a fix and a mystery.

Paper trade before going live — the graduation ladder

1. Backtest the logic on history (8.6). Kill it here if it doesn't work — cheapest funeral available.
2. Testnet/demo — every major exchange offers fake-money markets. Run the REAL code against them for 2–4 weeks. You're testing behaviour, not profit: does it size right, stop right, log right, handle a dropped connection without ordering nineteen times?
3. Live, embarrassingly small — the minimum order size, for weeks. Real fees, real slippage, real 3am weirdness, toy stakes.
4. Scale slowly — double size only after a full month of the bot doing exactly what the plan says. The bot earns trust like a new apprentice: gradually, with supervision, after demonstrated competence with the good tools.

The starter bot — real code

A complete, working skeleton of an RSI bot against an exchange testnet (this exact file ships in the Bonus Downloads):

Where does this code actually go?

1. Install Python — grab it from python.org/downloads. On Windows, tick "Add Python to PATH" on the first screen. Miss that box and every command below says "python is not recognised", which has ruined more evenings than leverage.
2. Install the exchange library — open Command Prompt (Windows) or Terminal (Mac), and run:
   pip install ccxt
   That one library talks to 100+ exchanges, which is why it's the default choice.
3. Save the code as a file — paste it into any plain-text editor and save it as rsi_bot.py. Notepad works; VS Code is free and far nicer (it colours the code and points at your typos). Not Word — Word adds invisible formatting that breaks it.
4. Set your TESTNET API keys — the code reads them from your environment, deliberately, so your keys never sit inside a file you might share. In Command Prompt:
   set API_KEY=your_testnet_key
set API_SECRET=your_testnet_secret
   (Mac/Linux: use export instead of set.) When you make those keys, enable Read and Spot trading only — never withdrawals. No bot ever needs to move money off the exchange.
5. Run it — in the same window, from the folder where you saved the file:
   python rsi_bot.py
   It'll print the RSI every minute and place testnet orders when the rule fires. Ctrl+C stops it.

Want to skip the fiddling? The Bot starter code pack in your Glovebox has this exact bot plus the other five, already wired up with a .env file for your keys, shared risk-limit code, and a README covering setup. Download it, run pip install -r requirements.txt once, and you're going.

import ccxt, time, os

exchange = ccxt.bybit({
    'apiKey': os.environ['API_KEY'],        # from environment — NEVER in code
    'secret': os.environ['API_SECRET'],
})
exchange.set_sandbox_mode(True)             # TESTNET. Stays True until 8.7's ladder says otherwise.

SYMBOL, TIMEFRAME, RSI_LEN = 'BTC/USDT', '1h', 14
RISK_USD = 20                               # fixed dollar risk per trade (8.9)

def rsi(closes, n=14):
    gains = [max(closes[i]-closes[i-1], 0) for i in range(1, len(closes))]
    losses = [max(closes[i-1]-closes[i], 0) for i in range(1, len(closes))]
    ag, al = sum(gains[-n:])/n, sum(losses[-n:])/n
    return 100.0 if al == 0 else 100 - 100/(1 + ag/al)

in_position = False
while True:
    try:
        candles = exchange.fetch_ohlcv(SYMBOL, TIMEFRAME, limit=100)
        closes = [c[4] for c in candles]
        r = rsi(closes, RSI_LEN)
        print(time.ctime(), SYMBOL, 'RSI =', round(r, 1))

        if r < 30 and not in_position:
            price = closes[-1]
            stop = price * 0.98                      # 2% stop
            size = RISK_USD / (price - stop)         # position sizing, 8.9 maths
            exchange.create_market_buy_order(SYMBOL, size)
            in_position = True
            print('BOUGHT', size, 'stop at', stop)
        elif r > 55 and in_position:
            bal = exchange.fetch_balance()['BTC']['free']
            exchange.create_market_sell_order(SYMBOL, bal)
            in_position = False
            print('SOLD — back to watching')
    except Exception as e:
        print('ERROR (logged, not panicking):', e)
    time.sleep(300)                                  # check every 5 minutes

Forty lines. It fetches data, applies a rule, sizes by risk, places orders, logs, survives errors, and repeats. Everything else in bot-land is this skeleton with more muscles.

The six projects — your bot apprenticeship