Development of Advanced OpenAlgo-Based ORB Trading Strategy (BrahmosV1) with Multi-Broker Support

@loxtic

Hi, how are you doing? I have hands-on Python experience with OpenAlgo, Zerodha/Fyers APIs, WebSocket data handling, and multi-threaded trading architecture, plus solid work with DuckDB/PostgreSQL and OMS logic. I’ve built modular, production-ready strategy code with externalized configs and robust logging, and I’ve integrated complex ORB-like strategies in OpenAlgo-compatible setups while keeping everything aligned with the platform’s docs. I can map symbols accurately, manage multi-segment and multi-timeframe trading, and implement reliable pre-market to market-time flows with real-time risk controls. Let me know further if interested.

@kingxanda

Hey, Thanks for your post. I'v read your description carefully. I have relevant experience I can help. some of my skills are: JavaScript, Python, Nodejs, EAs, trading etc Hope you're having a nice day my friend :)

@techmadigital

Cheap work is expensive later. If you want this done properly with scalable architecture and real execution, let’s discuss. I build products that actually work in production.

@LetsDevelope

I have experience building Python-based algo trading systems with broker APIs, websocket market feeds, OMS logic, and database-backed trading architectures. I can develop your OpenAlgo-compatible BrahmosV1 ORB strategy with modular design, configurable parameters, futures rollover handling, multi-broker support, and production-grade logging. I understand real-time execution requirements, risk management, and scalable strategy engineering for Zerodha/Fyers environments.

@letswork92

As an experienced Python algo trading developer with over 12 years in the field, I understand the complexities involved in creating a robust ORB trading strategy. Your requirement for a seamless integration of the BrahmosV1 strategy into the OpenAlgo platform, ensuring compatibility with Zerodha and Fyers APIs, is crucial for real-time market performance. I have extensive experience with Websocket programming and multi-threaded architectures, essential for handling real-time trading systems and futures rollover logic. Additionally, my proficiency with DuckDB and PostgreSQL ensures that your database requirements will be efficiently managed. I’m particularly keen on building an advanced Order Management System (OMS) tailored to your needs while ensuring that all configurations are externalized and scalable. What specific challenges do you foresee in integrating this strategy within the OpenAlgo environment?

@michaelb644

Hello, I have strong experience with Python-based algorithmic trading systems and can develop an advanced OpenAlgo ORB solution with clean architecture, automation, and scalable execution logic. My experience includes: OpenAlgo integration ORB (Opening Range Breakout) strategy development Python automation API integrations Real-time market data handling Risk management systems Backtesting & strategy optimization WebSocket/live execution systems Trading dashboards and monitoring tools What I can deliver: High-performance Python backend Modular and maintainable codebase Advanced ORB logic implementation Secure API handling Fast execution flow Logging & analytics Strategy customization Deployment support I understand the importance of stability, latency, and clean execution in automated trading environments and can start immediately. Looking forward to discussing the project in more detail. Best regards Michael

@abrider24

Hire me, I have experience.........................................................................................................>

@buildwithme101

HI I have worked on Python trading projects. I know how to connect to broker APIs handle market data from websockets and use databases like PostgreSQL and DuckDB. I have also built systems that can handle tasks at the same time and manage orders in real-time. I can build the BrahmosV1 strategy to work with OpenAlgo. It will be able to switch between short modes use data from different timeframes handle futures rollover and avoid duplicate trades. I will also include order management, logging and settings that can be changed easily. I will follow the OpenAlgo rules. Deliver code that is easy to understand and modify. I will provide instructions, on how to set it up and help with testing. Note: This project seems complex. I want to review the specific rules and OpenAlgo setup before I confirm everything. Thanks.

@borisalvarez

I have extensive experience in Python algo trading, OpenAlgo platform, Zerodha and Fyers APIs, websocket market data handling, real-time trading systems, DuckDB/PostgreSQL, multi-threaded trading architecture, futures rollover handling, advanced order management systems (OMS), and other relevant areas. I am confident that I can deliver a high-quality implementation of the BrahmosV1 ORB strategy as per your requirements.

@madele0

Hello, I'm Mohamed Adele, a Python Algo Trading Developer with deep experience building real-time trading engines and integrating broker APIs. I would love to build your BrahmosV1 Opening Range Breakout (ORB) trading strategy with multi-broker support on the OpenAlgo platform. Key highlights of my implementation plan: 1. Multi-Broker & WebSocket Integration: Connect Zerodha Kite and Fyers APIs using Python's async/WebSockets for zero-latency, real-time market tick data streaming. 2. Opening Range Breakout (ORB) Logic: Develop highly precise breakout detection based on custom timeframes, handling orders and pre-breakout candle tracking concurrently. 3. Multi-Threaded Engine with Local Storage: Implement a multi-threaded architecture to ensure order placement and tick-data processing happen independently. I will utilize DuckDB or PostgreSQL for high-speed local data persistence. 4. Risk Management & Rollover Handling: Build robust futures rollover logic and strict risk control mechanisms (trailing stop-loss, max daily drawdown, and instant slippage checks). I have configured advanced custom strategies in OpenAlgo and am fluent in financial APIs. Let's discuss your exact broker keys and ORB parameters to begin development! Best regards, Mohamed Adele

@JoseRCarvas

I'll build BrahmosV1 as a clean OpenAlgo strategy with Fyers multi-broker support, websocket-driven market data, DuckDB for state persistence, and proper futures rollover logic. **Deliverables:** - Fully functional BrahmosV1 ORB strategy inside OpenAlgo framework - Multi-threaded architecture with real-time websocket feeds - DuckDB logging for trades/orders - Advanced OMS with order lifecycle management - Fyers API integration tested for futures rollover Project runs inside OpenAlgo's Python Strategies directory with zero runtime errors. Code follows OpenAlgo documentation strictly. I'll provide full documentation and a live demo session. Let me know timeline constraints and broker API keys availability for testing.

@arrctechd

Hey! Fellow Punekar here — and I completely understand the ORB (Opening Range Breakout) strategy for Indian markets. It's one of the most powerful intraday setups, especially for Nifty/BankNifty Futures. I've worked with Python-based trading systems and API integrations. Here's how I'd approach your BrahmosV1 strategy on OpenAlgo: → OpenAlgo-compatible Python strategy module (strict doc standards) → ORB logic: First 15/30 min range detection, breakout entry with filters → Zerodha Kite + Fyers API integration → WebSocket real-time market data feed → DuckDB/PostgreSQL for trade logging → Multi-threaded architecture for low-latency execution → OMS (Order Management System) with SL/Target/Trailing logic → Futures rollover handling built-in I'll ensure zero runtime errors and full OpenAlgo documentation compliance. Delivery: 7 days | Budget: ₹4,500 (flexible for complexity) Quick question: Do you want the ORB timeframe to be 15-min or 30-min opening range? And should it work on paper trading mode first for testing? Let's build BrahmosV1 right!

@distroaryan

Hi, I've studied your BrahmosV1 requirements and the OpenAlgo GitHub repo thoroughly. Here's how I'd approach it: Architecture: • strategy_core/ — ORB engine, multi-TF candle builder • oms/ — Tier-15 SL/TGT engine with pluggable SL modes • feeds/ — Websocket handlers (Fyers/Zerodha) with fallback • data/ — DuckDB, futures rollover, watchlist sync • config/ — Fully externalized YAML (zero hardcoding) Key decisions: — CandleAggregator builds 5m–Monthly candles from ticks via thread-safe queues — DeduplicationManager enforces one-trade/symbol atomically across threads — Each of the 19+19 combos defined as config-driven ConditionSets — toggle conditions without touching code — All 6 SL modes implemented as a pluggable StopLossStrategy pattern Deliverables: full modular source, YAML configs, OpenAlgo-compatible strategy files, DuckDB schema scripts, setup guide, 30-day bug fix support. Honest disclosure: I'm under a year in algo trading, but Python, real-time Websocket systems, and DuckDB are my core strengths — exactly where this build is most complex. I'm treating this as a portfolio project and am fully committed to the validation period. Suggest we use Milestone 1 for an architecture alignment call before writing production code. — Aryan