DEV Community

Emil Nielsen
Emil Nielsen

Posted on • Edited on

Building a No-Code Trading Bot Builder for Prediction Markets (Raven)

#tutorial #opensource #discuss #automation

Today I worked on Raven, a no-code trading bot builder for prediction markets. The goal is to improve usability, fix some bugs in the beta system, and experiment with a new strategy creation experience.

Raven is inspired by tools like n8n, but instead of automating APIs, it lets users visually design and deploy trading strategies for platforms like Polymarket.

Why Raven Exists

Right now, creating a trading strategy in Raven requires connecting multiple nodes visually.

While powerful, this approach can feel overwhelming for new users:

  • You must understand how nodes interact
  • You essentially "program visually"
  • Even simple strategies require multiple components

This is great for advanced users, but not ideal for beginners.

So the question became:

How do we keep the power of a node-based system while making it more accessible?

Introducing a Strategy Creation Wizard

To solve this, I’m working on a step-by-step strategy creation wizard.

Instead of starting with a blank canvas full of nodes, users go through guided steps:

Step 1: Select Venue

Choose where to trade:

  • Polymarket (and potentially others later)

Step 2: Market Scope

Define what kind of market strategy you want:

  • Single market
  • Event-based selection
  • Recurring series

Step 3: Market Selection

Users choose or paste a market (e.g. Polymarket URL), and the system extracts relevant options automatically.

This is one of the harder UX problems today, so simplifying input here is a big focus.

Step 4: Entry Strategy

This is where the actual trading logic is defined.

Users can select templates like:

  • Crossover strategy
  • Mean reversion
  • Market making
  • Custom strategy

And configure parameters like:

  • Position size
  • EMA periods
  • Price offsets

Step 5: Exit & Risk Management

Users define how trades close:

  • Exit on reverse signal
  • Exit on target conditions
  • Max hold time
  • Stop-loss / take-profit rules

We also introduce lifecycle hooks, such as:

  • Order filled
  • Order partially filled
  • Order failed or rejected
  • Timeout events

These allow post-trade automation like hedging or follow-up actions.

The Final Idea: From Wizard → Canvas

After completing the wizard:

  • A full strategy is generated automatically
  • It is converted into a node-based canvas
  • Users can still fine-tune everything manually

This keeps both worlds:

  • Beginner-friendly onboarding
  • Advanced flexibility for power users

Current Engineering Work

While building this, I also worked on several backend issues:

1. Stalled Bots Problem

Some bots:

  • Remain marked as “running”
  • But stop producing updates
  • Or lose WebSocket state

This required debugging heartbeat tracking and event queue behavior.

A possible improvement:

  • Auto-detect stalled bots
  • Restart or mark them as failed after a timeout window

2. S3 Session Loading Bug

I investigated an issue where:

  • A bot session shows as running
  • But loading historical data from S3 fails or returns incorrect state

This pointed to inconsistencies between:

  • Live session state
  • Archived session storage

3. P&L Calculation Issues

Another important bug:

  • Some users had incorrect leaderboard balances
  • P&L was not always consistent with closed trades

The system should compute:

P&L = sum(all closed trades in session)

But some cases still relied on snapshots instead of full recomputation.

This is being fixed by validating:

  • Trade history integrity
  • Session carry-over logic between bots in a season
  • Leaderboard correctness

Idea: Telegram Bot Monitoring

One interesting idea that came up:

Instead of only using the web UI, users could:

  • Monitor bots via Telegram
  • Start/stop bots remotely
  • Get status updates and alerts

The UI would still be used for building strategies, but Telegram becomes a lightweight control layer.

Real Trading vs Simulation

One major observation:

Simulation differs from real execution in one key way:

  • Simulation fills are instant
  • Real markets (e.g. Polymarket) have delays of seconds

That delay affects:

  • Stop-loss behavior
  • Take-profit accuracy
  • Market timing strategies

This is unavoidable and part of real-world trading systems.

Testing a Polymarket Bot Strategy

I also tested a simple strategy setup involving:

  • Market selection
  • Signal comparison
  • Entry condition triggers

Goal: verify that signals behave consistently across live execution.

Relevant Resources

Here are some useful references if you’re interested in similar systems:

  • Polymarket trading bot example:
    [Polymarket Trading Bot (BTC/ETH) GitHub]

    GitHub logo DextersSlab / Polymarket-Arbitrage-Trading-Bot

    Polymarket Arbitrage Bot | Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket Trading Bot | Polymarket Arbitrage Bot | Polymarket

    Polymarket Arbitrage Trading Bot (BTC, ETH Momentum Arbitrage trading bot)

    TypeScript bot for Polymarket CLOB V2 5-minute BTC and ETH Up/Down markets. It monitors Chainlink strike/spot vs order books, enters momentum-aligned positions late in each epoch, optionally completes the opposite leg for a boxed pair, and manages exits with configurable risk rules.

    You can check this bot pnl with this account.

    https://polymarket.com/@9g9g99

    My_account_Pnl
    BTC-ETH-Momentum-Arbitrage-Bot-9g9g99.mp4

    Built with @polymarket/clob-client-v2 and Node.js 20+. See V2_MIGRATION.md for Polymarket exchange upgrade notes.

    Features

    • Dual-market confirmation — BTC and ETH must align before entries (reduces false signals)
    • Chainlink Data Streams — strike at epoch open + live spot for spot_minus_strike
    • High-frequency monitor — REST CLOB /book polling (~150ms), merged btc/eth wave logs
    • Six strategy phases — buy1, buy2, buy3, buy4, risk1, risk2, risk3
    • Paper trading — simulated fills without live CLOB orders
    • Optional redeem — gasless redeem via Polymarket builder relayer after epoch end
    • Deposit wallet…
    View on GitHub

  • YouTube walkthrough of a similar bot system:
    Trading Bot Tutorial Video

  • My YouTube channel (updates & builds):
    Development Channel

Closing Thoughts

Raven is still in beta, and a lot of the current work is about:

  • Reducing friction for new users
  • Stabilizing long-running bots
  • Improving correctness of financial state (P&L, leaderboards)
  • Making strategy design more intuitive

The long-term goal is simple:

Make building and testing trading strategies as easy as dragging nodes and answering a few structured questions.

Top comments (0)