Signal LynxFrom Zero to Weapons-Hot
The Full Signal Lynx Setup: TradingView → Signal Shield → Lynx-Relay → Exchange
This is the end-to-end “how to wire the whole machine” note. Not theory. Not vibes. A real deployment path that keeps your keys local and your webhook receiver sane.
If you’ve ever looked at TradingView and thought:
“Cool. Now how do I automate this strategy so I don’t have to babysit the chart?”
…and also wondered how to do it without putting your wallet in a shared cloud honeypot — you’re in the right place.
Signal Lynx is built around one doctrine:
Automation for the Night-Shift Nation.
You’re busy. You want it safe, you want it simple, and you want it to keep working when you’re not staring at it.
We also follow the “not your keys, not your coins” mantra. Meaning: your exchange API keys stay on your hardware, stored locally, encrypted, and under your control. No cloud bot holding a pile of other people’s secrets in the same vault. No shared-key honeypot. No “trust us bro” middleman.
This note covers the full mission:
Fortify your rig → Arm the relay → Go weapons-hot.
The 10,000-ft view (the pipeline)
Here’s the clean architecture we’re deploying:
- TradingView is where you backtest and validate ideas using strategies.
- An indicator generates the real-time signal and fires an alert.
- TradingView sends that alert to your rig as a webhook (HTTPS).
- The alert includes a JSON payload that describes the execution plan (what to do, how to size, how to handle edge cases).
- Signal Shield hardens your Windows box and gives you a secure webhook “front door.”
- Lynx-Relay receives the webhook, validates it, applies execution logic, places the order, and monitors the order to make sure it actually gets done.
- Your exchange receives orders from your machine — using API keys stored locally.
Signals can come from the cloud. Execution doesn’t have to.
What you need before you start (keep it simple)
Don’t overbuild. You don’t need a NASA control room. You need a stable rig and sane permissions.
Minimum requirements
- A Windows machine that stays awake
Home rig works (if you control sleep & updates)
A Windows VPS is cleaner for 24/7 uptime
Need help deciding on a VPS? See our Night Shift Note:
Night Shift Rig Survival Guide: Picking a Windows VPS
- A supported exchange account & API key created with sane permissions
- TradingView account (obviously)
- Signal Lynx account (Command Center tools & downloads)
API key permissions (the sane defaults)
Rule #1: Do not enable withdrawals on any exchange.
That’s how a “trade bot” turns into a “full account wipeout bot.”
Suggested baseline permissions (trade-only):
Kraken
Binance.US / Binance Global
Gemini
IP whitelist (optional but strong)
If your API key will only ever be used from one machine (your rig/VPS), IP whitelisting is a great extra layer. It means the key only works from that machine’s public IP.
Just be honest about your setup:
Step 0 — Get Lynx-Relay (trial counts) & Signal Shield
Go to the Trading Automation page and subscribe (or start the trial):
signallynx.com/trading-automation
If you don’t have a Signal Lynx account yet, you’ll create one during the flow. That account also unlocks the Webhook Configurator (you’ll use it later).
After subscribing, go to your Account Arsenal / Downloads page:
signallynx.com/account/downloads
From there you’ll have:
- Lynx-Relay installer
- Signal Shield installer
- License keys for activation
Mission check: you have the tools & keys. No trades yet.
Step 1: Fortify your rig (Signal Shield)
Signal Shield is the “one-button bodyguard” for the webhook entry point.
What it does in normal human language:
- Installs/configures a hardened reverse proxy (NGINX)
- Locks down firewall rules
- Enables HTTPS so your webhook isn’t naked on the internet
- Makes your machine behave like a real webhook receiver instead of a weekend science project
This is the part that stops random internet scanners from knocking on your door all day.
Install & run setup
- Download Signal Shield from your downloads page and install it.
- Launch it. Paste your Signal Shield license key, click Activate, and confirm it turns Active/green.
- Unless you’re an NGINX pro, leave the advanced toggles alone and hit Run Setup.
You may see command windows pop in the background. That’s normal. It can take a while. When it’s done, your setup checks should be green.
Restart your PC after a successful setup.
This matters. Let the services initialize properly.
If something fails (lockouts happen sometimes when Windows is busy):
- Restart the PC
- Run Run Setup again
The manual part: router / firewall forwarding
Signal Shield hardens the box, but you still have to let TradingView reach it.
If you’re on a home rig behind a router, you must set up port forwarding so inbound HTTPS (port 443) reaches your machine. If you don’t do this, the webhook never arrives. Signal Shield’s Router Help section is where you’ll pull what you need (including your public IP).
If you’re on a VPS, you usually don’t “port forward,” but you still need to allow inbound 443 in the provider firewall/security rules.
What you should have now
- A secure webhook front door on your rig
- The foundation for Lynx-Relay to receive alerts safely
Mission check: you now have a hardened perimeter. Still no trades yet. Good.
Step 2: Arm the relay (Lynx-Relay)
Lynx-Relay is Mission Control. It lives on your machine and executes trades locally.
Core jobs:
- Runs the local webhook receiver
- Verifies incoming webhooks using your shared secret
- Executes orders on supported exchanges
- Handles execution edge cases (monitoring, retries, IOC logic, etc.)
- Gives you visibility (notifications, history, error logs)
- Optional Telegram alerts (radio calls when you’re not at your desk)
First-time setup checklist
- Install Lynx-Relay and launch it.
- Accept the EULA.
- Set your application password.
Important: treat that password like a vault key. If you lose it, you can recover via a vault reset, but that means re-entering exchange keys (and possibly regenerating them). We designed this way on purpose, for security.
Configure the vault & keys
Inside Lynx-Relay: select the “Update Keys” button on the home screen:
- Enter your Lynx-Relay license key
- Set your Webhook Secret (this same value must also be included in the TradingView alert JSON)
- Add your exchanges:
- Give each exchange profile a clear Account Name (you will reference this in the JSON)
- Enter API Key and API Secret
- Select the exchange provider from the dropdown
- Save (it takes a moment because it encrypts your keys)
- Strongly recommended: add Telegram Bot Token and Chat ID so you get alerts on your phone
Once saved, Lynx-Relay reinitializes and checks:
- License status
- Exchange connectivity
Green: good
Yellow/partial: something off in API keys or permissions
Mission check: Lynx-Relay is online, vault is configured, and it can talk to the exchange.
Step 3: Pick a strategy (Script Vault: 10 published, growing)
We publish scripts because this is where most people get tangled up when starting off with algo trading.
PineScript and TradingView have nuances. Backtesting isn’t perfect. Alerts behave differently than people expect. The vault exists to give you a cleaner on-ramp with automation-friendly structure.
Right now the vault has 10 scripts published, and we’ll keep pushing updates and new ideas.
If you want a clean start, begin with the heavy hitters:
- Super AO: swing chassis & modular RM engine (drop in your logic, keep the RM stack)
- Superior-RBR: volatility-aware Renko emulation & full RM template
- Gypsy Bot: consensus engine (modules vote; action only fires when enough agree)
For new traders, Super AO is a good first choice. It’s simpler to understand and still powerful.
Workflow recommendation:
- Backtest the strategy version
- Tune baseline parameters for your pair & timeframe
- Apply the same settings to the matching indicator/alerts companion
- Use the indicator to drive alerts (that’s what triggers Lynx-Relay)
Mission check: you have a strategy you trust, and you know what alert should fire.
Step 4: TradingView alert setup (URL first, then JSON)
TradingView alerts communicate with Lynx-Relay via:
- Webhook URL (where to send)
- JSON message (what to do)
Create the alert
When you add an alert in TradingView you’ll see tabs. The exact UI can vary slightly, but the flow is the same.
Settings tab
Condition: choose your Signal Lynx indicator/alert script
If using Signal Lynx published scripts we recommend the below settings:
Options
Trigger: Every time (so it fires on each valid signal)
Expiration: open-ended
Notifications tab
Enable Webhook URL
Set it to: https://YOUR_PUBLIC_IP/webhook
You can find your public IP via Signal Shield (Router Help section).
Warning: Enabling a bunch of extra notifications can slow things down. Keep it lean if automation is the mission.
Mission check: TradingView knows how and where to send the webhook.
Step 5 — Build the JSON payload (use the Webhook Configurator)
Now we craft the execution plan.
Use the Webhook Configurator:
signallynx.com/account/webhook-configurator
What it’s for:
- Enter your Webhook Secret (must match Lynx-Relay settings)
- Enter your Account Name (must match the exchange profile name in Lynx-Relay settings)
- Choose the exchange provider
Stack actions:
- cancel_orders
- wait
- place_order
Configure order details:
- pair
- order type
- sizing mode (quantity / percent / value)
- monitoring parameters (optional)
The big win: exchange-aware guardrails.
The configurator prevents you from building an action plan the exchange can’t execute.
Recommended “clean execution” pattern:
- cancel_orders (clear ghosts / stale orders)
- wait (~4 seconds is fine)
- place_order (with an order type that matches your intent)
Order type guidance
We recommend a cancel order statement up front (clearing the exchange of any ghost orders which somehow got left),
a short delay (~4 seconds), and placing your order. We recommend ioc_from_orderbook for Kraken, Binance.US and
Binance Global, and ioc_sweep_from_orderbook for Gemini. These are algo trader friendly limit orders that execute
quickly and enable default order mitigation to ensure the order is successfully placed.
Sizing guidance:
- Percent sizing is often easier for keeping risk proportional over time
- Quantity sizing is fine when you’re being very intentional and stable
Paste the JSON into the alert message
Once the configurator validates the JSON, copy it into the TradingView alert “Message” box.
If you have a good JSON, the box outline will go green. If you have a bad JSON, the box outline will highlight orange.
Check your JSON if you see the orange outline.
Mission check: you have a valid payload, and TradingView will send the exact plan to your secure endpoint.
Step 6 — Functional validation (prove the pipeline end-to-end)
Do not start live with size. That’s how you learn expensive lessons.
Suggested first test:
- Build a simple place_order with a tiny size
- Trigger an alert manually (or use an easy test condition on a low timeframe)
Then verify inside Lynx-Relay:
- Alert received
- Secret validated
- Exchange connected
- Order accepted (or a clear error shown)
Mission check: you’ve proven the full chain works.
Step 7 — Going weapons-hot (without doing something dumb)
This is where you graduate from “cool demo” to “real automation.”
Rules of engagement:
- Start small
- Use percent sizing where it makes sense
- Understand your order type behavior (market vs limit vs IOC variants)
- Don’t run fire-and-forget execution with zero monitoring
- If you’re using limits: have a plan for stalls, partial fills, retries
- Keep withdrawals disabled. Always.
Quick checklist:
- Signal Shield installed, webhook reachable, router/VPS firewall correct
- Lynx-Relay installed, vault created, exchange keys loaded
- TradingView alert created with webhook URL set
- JSON generated via configurator (not typed by hand)
- Test alert confirmed end-to-end
- Size turned down to “learning mode”
Only then: go weapons-hot.
Closing notes from the night desk
This stack exists for one reason:
Automation should not require surrendering your keys to a shared cloud bot.
Signals can come from the cloud. Execution doesn’t have to.
Fortify the rig. Arm the relay. Then go weapons-hot like an adult.
Not financial advice. This is ops. You own your risk, sizing, and decisions. We just supply better tools and cleaner doctrine.
References (copy/paste)
- Night Shift Notes: signallynx.com/night-shift-notes
- Trading Automation: signallynx.com/trading-automation
- Webhook Configurator (account required): signallynx.com/account/webhook-configurator
- Script Vault: tradingview.com/u/SignalLynx/#published-scripts