Brobot is my most recent deep dive into the world of fintech and high-stakes engineering. While my previous ventures focused on connecting people, Brobot was about connecting with the market, specifically the Canadian stock exchange.
I founded Brobot Capital with my brother, Octav, to solve a scalability problem. He had identified specific trading strategies involving “odd lots” and routing inefficiencies (specifically on the PURE network) that were profitable but impossible to scale manually. Humans simply cannot watch hundreds of tickers simultaneously and spot fleeting spread opportunities fast enough to act on them.
I built Brobot to surface exactly that. It is a monitoring and analysis system that tracks stocks and identifies arbitrage and spread opportunities in real time. Trade decisions were made by hand based on what the system surfaced. It wasn’t just a coding exercise; it was a business engine that required me to balance technical precision with financial risk.
At a high level, Brobot acts as a high-frequency analyst. It tracks the “Order Book” (the list of buyers and sellers for a specific stock) and looks for inefficiencies between different routing networks (like TSX vs. PURE). It specifically targets “odd lots” (non-standard share quantities) that offer better pricing but are often invisible to standard aggregators.
The bot listens to the market in real-time. When it detects an opportunity (for example, a gap between the best bid and the best ask), it calculates the optimal price point and surfaces it for review. The logic tracks both the buy side and the sell side simultaneously, giving us the information needed to manually act on spread opportunities while aiming to maintain a “net zero” position at the end of the day.
One of the most complex aspects of this project was the integration with a proprietary third-party trading system. Brobot doesn’t just run in isolation; it reads state from a complex execution layer to inform its analysis.
This required engineering a robust validation system to handle “Wash Trading” prevention. When surfacing opportunities, there is a risk that a suggested buy matches one of our own active sell orders on the exchange. This is illegal and financially draining. I built a logic layer that cross-references every detected opportunity against our active book within the proprietary system, ensuring that we never surface a trade that would cross the spread against ourselves.
While many HFT (High-Frequency Trading) systems are written in C++, I chose Ruby for its developer velocity and my deep expertise with it. The core challenge wasn’t just raw speed, but state management.
The system runs as a collection of independent processes. I built a custom Process Manager (using Windows API integration) that spawns a “Brain” for each ticker.
Trading blindly is terrifying. I built a full React/Next.js web interface that communicates with the Ruby backend via a REST API.
This was a family venture. My brother brought the domain expertise and the capital, and I brought the engineering architecture.
Working in a high-stakes environment where a bug could literally cost us money in seconds changed how I approach software development. There was no “fix it later.” The code had to be robust, the error handling had to be graceful, and the logging had to be forensic.
We built a system that supported a strategy generating consistent revenue. But beyond the profit, Brobot was a masterclass in risk management, system architecture, and the complexities of financial data pipelines. It proved that with the right tooling and architecture, a small team can operate effectively in some of the most competitive markets in the world.
emanuelpetre.dev