Office Hours Q&A: Trading Automation

Every trading platform faces the same challenge: translating trader intent into reliable broker execution. In this February 2025 office hours session, the TradersPost team addressed real questions from automated traders navigating the complexities of multi-broker integrations, position management, and platform capabilities.

New Slippage Insights Feature

Slippage—the difference between your expected entry price and actual fill price—is one of the most misunderstood aspects of automated trading. TradersPost recently launched slippage tracking to help traders understand the execution quality they're receiving.

The feature compares the signal price (the price at the moment your TradingView alert fires) with the actual fill price from your broker. This reveals two components of slippage:

Time Slippage: The delay between alert generation, webhook transmission, order processing, and broker execution. Even a few seconds can result in price movement, especially on volatile assets.

Market Slippage: The inherent bid-ask spread and order book depth when your order executes. Large orders on thinly traded assets face worse slippage as they "walk through" multiple price levels.

When you're trading automated strategies, understanding your slippage patterns is critical. If you're consistently losing 0.2% to slippage on entries, that's 0.4% round-trip per trade. A strategy with 2% average profit per trade just lost 20% of its edge to execution costs.

The slippage stats help you answer questions like:

• Is my strategy viable for live trading given typical slippage?
• Should I use limit orders instead of market orders?
• Am I trading the right time of day for optimal liquidity?
• Does my broker's execution quality match their advertised performance?

Broker Performance Comparison

Not all broker integrations are created equal. The TradersPost team shared eye-opening performance metrics:

Alpaca and Robinhood: Sub-50 millisecond average response times, often 20-30ms

Interactive Brokers: 500+ milliseconds average, sometimes much longer

This 10x difference stems from architectural choices. Alpaca and Robinhood built modern APIs from scratch with concurrent request handling. Interactive Brokers' API layers on top of Trader Workstation (TWS), their GUI trading application.

When you send an API call to IBKR, it's essentially proxying through a virtual TWS instance. This creates a fundamental concurrency bottleneck—only one operation can proceed at a time per account. Try to execute two orders simultaneously and they queue up, with the second waiting for the first to complete.

For automated strategies placing multiple orders across different symbols, this architecture causes:

• Frequent timeout errors during high-frequency execution periods
• Unpredictable order sequencing when signals arrive close together
• Higher rejection rates during volatile market conditions

TradersPost implements retry logic and waits up to 10 seconds total (including one retry) before timing out. Ten seconds is an eternity in automated trading, yet IBKR sometimes exceeds even this generous threshold.

Why Traders Stick with Interactive Brokers

Despite these challenges, many traders have no choice but to use IBKR. The broker offers:

• Global market access unavailable elsewhere
• Support for international traders shut out of US brokers
• Low margin rates and extensive product offerings
• Decades of institutional credibility

For non-US traders wanting to automate US equity strategies, or anyone needing exotic products like international futures or forex, IBKR may be the only option. The platform improvements TradersPost makes—like batch processing and better error handling—help mitigate IBKR's API limitations.

There's speculation (based on research calls and surveys IBKR conducted with API users) that they're developing a modernized API to compete with newer brokers. Until that launches, traders must accept IBKR's current constraints as the price of access.

Crypto and Fractional Quantities

A trader asked about an error message: "fractional quantity cannot be used with stop losses." This issue arises specifically with Alpaca's crypto trading.

Alpaca supports different features across asset classes:

• Stocks: Full bracket order support with take profit and stop loss
• Crypto: No bracket orders or advanced order types
• Options: Limited to basic orders

When trading crypto on Alpaca through TradersPost, you can use fractional quantities (0.5 BTC), but you can't attach stop losses directly to your entry order. Instead, your stop loss must be managed through your strategy logic in TradingView, sending a separate exit signal when stop conditions are met.

This isn't a TradersPost limitation—it's an Alpaca restriction. The broker simply doesn't support advanced order types for cryptocurrency trading. TradersPost can't create functionality that the broker's API doesn't provide.

The solution: Use basic orders for crypto entries and manage risk through your strategy code. Your TradingView alerts should fire exit signals based on stop loss or take profit conditions, rather than relying on broker-held orders.

The Dynamic Quantity Challenge for Futures

Another common question: "Why can't I use 'amount per position' or 'percent of equity' for futures trades?"

With stocks, crypto, and options, calculating position size from account equity is straightforward:

• Account balance: $100,000
• Percentage to risk: 10%
• Position size: $10,000
• Stock price: $50
• Shares to buy: 200

The cost equals the price times the quantity. Simple math.

Futures are different. The notional value of a contract (the value of the underlying asset it controls) is separate from the margin requirement (the capital actually locked up for the position).

Example with NQ (Nasdaq-100 E-mini):

• Index price: 21,200
• Contract multiplier: $20 per point
• Notional value: 21,200 × $20 = $424,000
• Initial margin: ~$10,000 (varies by broker and volatility)

To calculate "use 50% of my $100,000 account" requires knowing the margin requirement. But this value:

• Changes daily based on volatility
• Varies between brokers
• Adjusts intraday during extreme market conditions
• May differ for day trading vs. overnight positions

Most broker APIs don't expose real-time margin requirements. Without access to this data, TradersPost can't reliably calculate position sizes for futures contracts.

Some brokers like TradeOvate (Trade Station's futures platform) may provide margin data through their API. Even so, implementing position-sizing logic that works consistently across all futures brokers is technically infeasible without universal API standards.

The workaround: Specify contract quantities directly in your strategy, or build custom position-sizing calculations in PineScript that you control.

The Bracket Order Dilemma

Multiple traders asked variations of: "If my broker doesn't support bracket orders, can TradersPost submit separate take profit and stop loss orders?"

Technically yes, but practically no—here's why:

What Bracket Orders Do:

A bracket order (also called OCO: one-cancels-other) links your entry, take profit, and stop loss together. When your stop loss fills, the broker automatically cancels your take profit order, and vice versa.

Without Native Bracket Support:

If TradersPost submits unlinked TP and SL orders:

1. Your entry fills at $100

2. Take profit is placed at $105

3. Stop loss is placed at $95

4. Price drops, stop fills at $95

5. Take profit order remains active at $105

6. Price recovers to $105

7. Take profit fills, entering a new position instead of exiting

You've turned a protective exit into an unintended entry—the opposite of risk management.

The Algorithmic Order Solution:

TradersPost could monitor order fills in real-time and cancel corresponding orders programmatically. But this introduces critical risks:

• WebSocket disconnections: If the connection drops, orphaned orders remain
• Regulatory issues: Some brokers prohibit "algorithmic order" behavior in their terms (Schwab explicitly does)
• Reliability concerns: A protective stop loss only works if it's guaranteed to execute

For a risk management feature to be trustworthy, it needs to work 100% of the time. Building custom OCO logic that meets this standard is technically complex and regulatory risky.

The Recommendation:

Use brokers with native bracket order support for strategies requiring guaranteed stops. Alternatively, manage protective exits through your strategy logic in TradingView, where you control the conditions and timing.

Adding Asset Class to Subscriptions List

A simple but useful request: show the asset class (stocks, crypto, futures, options) on the subscriptions list page.

Currently, TradersPost displays:

• Strategy name
• Broker connection
• Enabled/disabled status
• Auto-submit toggle

Adding asset class as a badge (similar to how it appears on the strategies page) would help traders quickly identify which subscriptions trade which asset types, especially when managing multiple strategies across different accounts.

This kind of incremental UI improvement—small individually but impactful cumulatively—is how platforms evolve to meet trader needs. User feedback directly shapes the roadmap.

The Connections Page Redesign

TradersPost recently overhauled the broker connections page to surface which features work with which asset classes for each broker.

Previously, you might connect Trade Station expecting take profit and stop loss support, then discover it only works for equities—not futures or options. The new page shows a detailed grid:

| Feature | Stocks | Futures | Options | Crypto |

|---------|---------|---------|---------|--------|

| Bracket Orders | ✓ | ✓ | ✗ | ✗ |

| Trailing Stops | ✓ | ✓ | ✗ | ✗ |

| Fractional Shares | ✓ | N/A | N/A | ✓ |

This transparency helps traders choose the right broker for their strategy type before investing time in setup and testing.

The page also groups brokers by asset class, letting you filter to only see futures brokers if that's your focus. This information architecture makes the complex landscape of multi-broker capabilities navigable.

Key Insights from This Session

Execution Quality Matters: Slippage tracking reveals the true cost of automation. Know your numbers before scaling.

Broker APIs Vary Wildly: Response times, reliability, and feature support differ dramatically between providers.

Futures Are Special: Margin-based instruments require different position sizing approaches than cash instruments.

Risk Management Has Limits: Platforms can only implement features their broker APIs support—know the constraints.

Transparency Builds Trust: Showing users exactly what works where and why prevents frustration and failed expectations.

International Access Is Challenging: Many trading restrictions are geographic, not technical, limiting automation options for non-US traders.

What This Means for Your Automation Strategy

When planning your automated trading approach:

1. Test execution quality with small size before scaling. Monitor slippage across different times of day and market conditions.

2. Choose brokers strategically based on your strategy needs. Don't assume all brokers support all features for all assets.

3. Build risk management into strategy logic rather than relying solely on broker-held orders. This gives you maximum control.

4. Understand your broker's API limitations and plan around them. IBKR's concurrency issues might require sequential rather than parallel order submission.

5. Use the right position sizing method for each asset class. Percentage-based works for stocks and crypto, but futures need fixed contracts.

6. Communicate with your execution platform about issues and feature requests. User feedback directly shapes development priorities.

The gap between strategy conception and reliable execution is where most automated trading dreams die. Understanding broker limitations, slippage costs, and platform capabilities transforms that gap from an insurmountable obstacle into a manageable challenge. Focus on what's possible with current technology, work within the constraints, and automate the pieces that genuinely benefit from automation while keeping human oversight where it adds value.

Looking Forward

Platform development continues in several key areas:

Real-Time Order Updates: WebSocket integration for instant order status changes without page refreshes

Enhanced Analytics: Strategy-level performance metrics including Sharpe ratio, maximum drawdown, and win rate

Custom Webhooks: Ability to relay trade events to external services like Discord, Telegram, or custom applications

Multi-Account Scaling**: Improved interfaces for managing dozens of strategy subscriptions across multiple broker accounts

Each enhancement builds on the foundation of reliable execution and transparent communication between your strategies, TradersPost, and your brokers. The goal remains constant: make institutional-quality trade automation accessible to retail traders with the resources they have access to today.

Whether you're running a single strategy on one broker or managing a portfolio of algorithms across multiple accounts and asset classes, understanding the practical realities of automated execution separates successful traders from disappointed ones. The infrastructure exists—now it's about using it effectively within its capabilities.