import pandas as pd

def generate_signals(df: pd.DataFrame, fast_ma: int = 5, slow_ma: int = 10, vol_period: int = 20) -> pd.DataFrame:
    df['fast_ema'] = df['close'].ewm(span=fast_ma, adjust=False).mean()
    df['slow_ema'] = df['close'].ewm(span=slow_ma, adjust=False).mean()
    df['vol_avg'] = df['volume'].rolling(window=vol_period).mean()
    
    # Generate signals
    df['signal'] = 0
    df.loc[(df['fast_ema'] > df['slow_ema']) & (df['fast_ema'].shift(1) <= df['slow_ema'].shift(1)) & (df['volume'] > df['vol_avg']), 'signal'] = 1 # Buy
    df.loc[(df['fast_ema'] < df['slow_ema']) & (df['fast_ema'].shift(1) >= df['slow_ema'].shift(1)) & (df['volume'] > df['vol_avg']), 'signal'] = -1 # Sell
    
    return df

# Example usage with dummy data
data = {
    'close': [100, 101, 102, 101, 103, 104, 105, 104, 103, 102, 101, 100, 99, 98, 97, 96, 95, 96, 97, 98],
    'volume': [100, 120, 150, 80, 200, 250, 300, 180, 150, 120, 100, 90, 80, 70, 60, 50, 40, 60, 70, 80]
}
df = pd.DataFrame(data)
df_signals = generate_signals(df)
print(df_signals[df_signals['signal'] != 0])

Step 2 – Implement Rapid Execution with an API

Once you have signals, fast execution is paramount in high-frequency scalping. You'll need to integrate with a brokerage API to place orders programmatically. The core idea is to subscribe to real-time market data, generate signals on the fly, and send orders with minimal latency.

Most brokers offer Python SDKs. While the specifics vary, the general workflow involves:

1. Connecting to the API: Authenticate your application.
2. Subscribing to Data: Get live price updates (e.g., last price, bid/ask spread) for your chosen asset. For in-depth data and API usage, refer to the RealMarketAPI Docs.
3. Order Placement: Send market or limit orders when a signal is generated.
4. Order Management: Track your open positions and close them quickly when your profit target is met or a stop-loss is triggered.

# Pseudocode for API integration

class ScalpingBot:
    def __init__(self, api_key, api_secret, symbol='SPY', quantity=1):
        self.api = BrokerageAPI(api_key, api_secret) # Initialize your broker's API client
        self.symbol = symbol
        self.quantity = quantity
        self.position = 0 # 0: no position, 1: long, -1: short
        self.data_buffer = [] # To store recent price data

    async def on_new_tick(self, tick_data):
        self.data_buffer.append(tick_data) # Add new data
        # Keep buffer size small for HFT
        if len(self.data_buffer) > 100: 
            self.data_buffer.pop(0)

        df = pd.DataFrame(self.data_buffer)
        df_signals = generate_signals(df.tail(20)) # Use only recent data for signals

        current_signal = df_signals['signal'].iloc[-1]

        if current_signal == 1 and self.position == 0: # Buy signal and no open position
            # Place buy order (e.g., market order for speed)
            await self.api.place_order(self.symbol, 'buy', self.quantity, 'market')
            self.position = 1
            print(f"⚡ BUY {self.symbol} @ {tick_data['price']}")
        elif current_signal == -1 and self.position == 0: # Sell signal and no open position
            # Place sell order
            await self.api.place_order(self.symbol, 'sell', self.quantity, 'market')
            self.position = -1
            print(f"⚡ SELL {self.symbol} @ {tick_data['price']}")
        # Add logic to close positions quickly based on profit target or time

    async def start(self):
        # Connect to WebSocket/data stream and pass ticks to on_new_tick
        await self.api.stream_market_data(self.symbol, self.on_new_tick)

# To explore different approaches for refining your scalping strategy, you might find 
# [Reliable OBV Scalping: 2 Dev Approaches for Precision Trading](/blog/reliable-on-balance-volume-obv-scalping-for-developers) helpful.

Step 3 – Backtest and Refine Your Exit Strategy

An entry signal is only half the battle; how you exit a trade dictates profitability. For HFT scalping, exits must be even faster than entries. Your goal is to capture tiny profits and cut losses immediately.

• Fixed Profit Target/Stop Loss: Set a very small profit target (e.g., 0.05% of the instrument's price) and an equally small, or slightly larger, stop loss. For instance, if you buy at $100, aim to sell at $100.05 and cut losses at $99.95. The key is to enforce these strictly.
• Time-Based Exit: If a trade doesn't hit its profit target or stop loss within a very short timeframe (e.g., 30-60 seconds), close it. This prevents getting stuck in sideway markets.
• Backtesting: Before live trading, rigorously backtest your strategy using historical tick data. This helps you understand its performance characteristics, drawdown, and potential profitability under various market conditions. Tools like backtrader or custom backtesting scripts using pandas are excellent for this.

# Pseudocode for Backtesting & Exit Logic

def backtest_scalping(historical_data: pd.DataFrame, profit_target_pct: float = 0.0005, stop_loss_pct: float = 0.0005, max_hold_time_ticks: int = 60) -> dict:
    signals_df = generate_signals(historical_data.copy())
    trades = []
    open_trade = None # (entry_price, entry_time_index, signal_type)
    
    for i, row in signals_df.iterrows():
        if open_trade: # Manage open trade
            entry_price, entry_idx, signal_type = open_trade
            current_price = row['close']

            # Check for profit target or stop loss
            if signal_type == 1: # Long position
                if current_price >= entry_price * (1 + profit_target_pct):
                    trades.append({'entry': entry_price, 'exit': current_price, 'type': 'long', 'pnl': current_price - entry_price})
                    open_trade = None
                elif current_price <= entry_price * (1 - stop_loss_pct):
                    trades.append({'entry': entry_price, 'exit': current_price, 'type': 'long', 'pnl': current_price - entry_price})
                    open_trade = None
            elif signal_type == -1: # Short position
                if current_price <= entry_price * (1 - profit_target_pct):
                    trades.append({'entry': entry_price, 'exit': current_price, 'type': 'short', 'pnl': entry_price - current_price})
                    open_trade = None
                elif current_price >= entry_price * (1 + stop_loss_pct):
                    trades.append({'entry': entry_price, 'exit': current_price, 'type': 'short', 'pnl': entry_price - current_price})
                    open_trade = None

            # Time-based exit
            if open_trade and (i - entry_idx) >= max_hold_time_ticks:
                trades.append({'entry': entry_price, 'exit': current_price, 'type': 'time_out', 'pnl': current_price - entry_price if signal_type == 1 else entry_price - current_price})
                open_trade = None

        if not open_trade and row['signal'] != 0: # New signal and no open trade
            open_trade = (row['close'], i, row['signal'])

    # Summarize results
    if not trades: return {'total_pnl': 0, 'num_trades': 0, 'win_rate': 0}
    total_pnl = sum(t['pnl'] for t in trades)
    wins = sum(1 for t in trades if t['pnl'] > 0)
    num_trades = len(trades)
    win_rate = (wins / num_trades) * 100 if num_trades > 0 else 0

    return {'total_pnl': total_pnl, 'num_trades': num_trades, 'win_rate': win_rate}

# For specific indicator hedging strategies, see 
# [5 Steps to Master NVDA Williams %R Hedging on H1](/blog/5-steps-to-master-nvda-williams-r-hedging-on-h1).

Common Mistakes to Avoid

• Over-optimization (Curve Fitting): Don't tweak your strategy parameters until it performs perfectly on historical data. This often leads to poor performance in live markets. Test on unseen data.
• Ignoring Transaction Costs: Commissions, slippage, and spread can quickly erode small profits in HFT. Factor these into your backtesting and profitability calculations.
• Lack of Robust Error Handling: Your bot will encounter API connection issues, unexpected data formats, or failed orders. Implement comprehensive error logging and graceful recovery mechanisms to prevent catastrophic losses.
• Insufficient Hardware/Network Latency: HFT is sensitive to speed. Running your bot on slow internet or a distant server can put you at a disadvantage. Consider VPS hosting close to exchange servers.

Conclusion 🚀

Building a high-frequency scalping strategy for beginners is an exciting challenge that blends programming with market savvy. You've learned to define an edge with simple indicators, implement rapid execution via APIs, and refine your exit strategy through rigorous backtesting. Remember that HFT is an iterative process requiring constant monitoring and adjustment.

Your next steps should involve deeper dives into market microstructure, understanding order books, and exploring more sophisticated statistical arbitrage or mean-reversion techniques. Keep experimenting, keep coding, and let your bots compete in the fast-paced world of algorithmic trading!