Nasdaq Futures Automated Trading System

Automated Futures Trading Signal → Broker Execution System

I am looking for an experienced developer to build an automated trading execution system for Nasdaq futures (NQ/MNQ).

What I Want to Build

I currently receive trading signals in text/message format. I want software that can automatically read these signals, interpret the trading instruction, and execute the appropriate trade through my futures brokerage account.

The objective is:

Trading Signal → Parse Instruction → Validate → Execute Trade → Automatically Manage Position

The system should be capable of operating 24 hours per day during futures trading hours, Monday–Friday, without requiring me to manually enter each trade.

Example Signal

A signal might look something like:

SHORT NQ 20750

The system should recognise:

* Instrument: NQ
* Direction: Short
* Entry: 20,750

It should then automatically place the appropriate order through my broker.

I want position sizing and risk parameters to be configurable rather than hard-coded.

For example:

* Trade 6 MNQ contracts
* Initial stop loss: 45 points
* Initial profit target: 70 points

I should be able to change these settings easily.

Position Management

This is particularly important.

I do not simply want a basic entry + stop loss + take profit bot.

Some trades may move 100, 200, 300, 400 or 500+ points, so I want the system to allow part of the position to remain open for larger moves.

For example, with 6 contracts:

Entry

* Buy/sell 6 contracts.

At +70 points

* Close 3 contracts.
* Move the stop on the remaining 3 contracts to breakeven.

At +150 points

* Potentially close another contract.

Remaining position

* Allow the final contracts to run with either a configurable trailing stop or further profit targets.

These parameters must be configurable.

Follow-Up Signal Instructions

The signal provider may subsequently send messages such as:

* “Scale out”
* “Sell some”
* “Take partials”
* “Move stop to breakeven”
* “Move SL to 20800”
* “Close position”
* “Exit all”
* “Hold runners”

I want the software to associate these follow-up messages with the existing position and modify the orders/position appropriately.

The exact wording of signals may vary, so the parsing system needs to handle a defined range of message formats reliably.

I am open to using either deterministic parsing/rules or an LLM-assisted parser, but trade execution should have strict validation rules before any broker order is submitted.

Entry Logic

I would also like configurable entry behaviour.

For example, if a SHORT signal arrives at 20,750 but the market is currently 20,745, the system should follow predetermined rules rather than blindly executing at any price.

Possible settings could include:

* Maximum acceptable slippage from signal price
* Market order
* Limit order
* Wait for price to return to the specified entry zone
* Cancel signal if price has moved too far
* Signal expiry after X minutes

I would like the developer to help design this safely.

Broker/API

The system needs to connect to a futures broker/API that supports automated NQ/MNQ execution.

I am open to discussing the best architecture depending on broker compatibility.

The system should be designed so that the broker/execution layer can ideally be changed later without rebuilding the entire signal-processing system.

Safety Controls

Reliability and risk management are extremely important.

I want safeguards including:

* Maximum contracts per trade
* Maximum total open exposure
* Maximum daily loss
* Maximum number of trades per day
* Duplicate-signal protection
* Signal expiry
* Maximum permitted entry slippage
* Automatic stop-loss placement
* Reject malformed/ambiguous signals
* Prevent accidental duplicate positions
* Connection/API failure handling
* Order rejection handling
* Partial-fill handling
* Broker/account position reconciliation
* Emergency CLOSE ALL / KILL SWITCH
* Detailed error logging

If the system cannot confidently interpret a signal, I would rather it not trade than guess.

Dashboard / Control Panel

Ideally, I would like a simple dashboard where I can see:

* Broker connection status
* Current NQ/MNQ price
* Current position
* Entry price
* Unrealised P&L
* Stop-loss level
* Profit targets
* Signals received
* Orders submitted
* Filled/rejected orders
* Daily P&L

I should also be able to:

* Enable/disable automatic trading
* Close individual positions
* Close everything immediately
* Change contract quantity
* Change stop distance
* Change profit targets
* Change scale-out rules
* Change breakeven rules
* Change maximum daily loss

Trading Schedule

The system should be capable of running throughout the futures trading week.

It should correctly handle:

* Exchange trading hours
* Daily maintenance periods
* Weekends
* US market holidays
* Futures contract expiry
* NQ/MNQ contract rollovers

I can manually control contract rollover if necessary, but I would prefer the architecture to make this straightforward.

Logging

Every action should be logged with timestamps, including:

Original signal → Parsed instruction → Validation decision → Broker order → Broker response → Fill → Position modification → Exit

This is important so that I can audit exactly what happened if something goes wrong.

Testing

I do NOT want the developer immediately connecting an untested system to a live futures account.

Development should ideally progress through:

1. Signal parser testing
2. Historical/example signal testing
3. Broker paper/simulation account
4. End-to-end testing
5. Failure/reconnection testing
6. Small-size live deployment
7. Full deployment after validation

Technical Expectations

I am looking for someone with experience in at least some of the following:

* Python / C# / appropriate trading-development language
* Futures trading APIs
* Broker APIs
* WebSockets / real-time market data
* Order-management systems
* Automated trading systems
* NQ/MNQ futures
* Stop/limit/bracket orders
* Position reconciliation
* Reliable message parsing
* Deployment/monitoring of 24/5 applications

Previous experience building live automated trading execution systems is strongly preferred.

Deliverables

I want:

* Complete working application
* Signal ingestion/parser
* Broker API integration
* Automated order execution
* Position-management engine
* Risk-management layer
* Logging
* Basic dashboard/control panel
* Paper-trading environment
* Deployment instructions
* Source code
* Documentation explaining how everything works

The code and system should be handed over to me at completion rather than remaining dependent on the developer.

When Applying

Please tell me:

1. What automated trading systems you have previously built.
2. Which futures broker APIs you have worked with.
3. Whether you have experience with NQ/MNQ.
4. How you would architect this system.
5. How you would safely interpret follow-up instructions such as “scale out” and associate them with an existing trade.
6. How you would prevent duplicate or incorrectly interpreted signals from creating trades.
7. Which language/technology stack you recommend.
8. Estimated development time.
9. Estimated total cost.
10. Whether you can provide ongoing support after deployment.

Please do not apply if your experience is limited to TradingView indicators/strategies. I specifically need someone comfortable with broker API integration and live order execution.