I’m building automated trading bots for Polymarket. The work sits somewhere between market research and systems engineering: processing live data, deciding what to quote, and dealing with what actually happens after an order goes out.

My role
Independent developer and researcher
Stack
Python, Rust, WebSockets, REST APIs
Focus
Market making and event-driven execution
Status
Ongoing personal project

What I’m building

One part of the project is market making: placing quotes on both sides of a market and studying when those quotes get filled. Another is event-driven execution, looking at price dislocations around changes in the underlying market or event.

Both depend on the same basic problem. A strategy needs a useful picture of the market before it can make a useful decision. That means handling order-book updates, market data, and external price feeds as events arrive.

Market events flow through a tick-based pipeline into strategy and order execution, with results feeding back into research.
A high-level view of the project. The arrows show the data and research flow.

From data to an order

  1. Receive market events. WebSocket feeds provide order-book and price updates; REST APIs cover request/response interactions with the market.
  2. Process the updates. Tick-based pipelines turn incoming events into inputs for the strategy.
  3. Make an execution decision. The bot evaluates quotes or an event-driven opportunity and interacts with the order API.
  4. Study the result. Execution and market data feed back into the research, including analysis of adverse selection.

Why the fills matter

For a market-making strategy, getting filled is only part of the story. A quote can look attractive when it is placed, then get hit just as the market moves against it. That is why adverse selection is a central part of this work.

I’m interested in the connection between the strategy and its execution: the data the bot saw, the decision it made, and what the market did afterwards. It gives me a much more useful way to examine a trading system than looking at an isolated signal.

What this project brings together

This is where I use Python and Rust alongside streaming APIs and market data. It combines the research side of my Data Science background with the operational questions I deal with at work: what state is the system in, what changed, and how do I explain its behaviour?

The project is ongoing. This page is an engineering overview; it doesn’t publish private strategy parameters, account details, or trading performance claims.

Related work

Before this, I built MT4/MT5 FX trading bots. I’ve also written about reconstructing a midnight scalping strategy from old trade logs and researching a regime-aware DCA strategy. Both write-ups are in the writing archive.