How the Poor Man's Covered Call Strategy Uses LEAPS to Replicate Covered Call Exposure

The Poor Man's Covered Call (PMCC) strategy uses a deep-in-the-money LEAPS call option with delta approaching 1.0 to replicate stock ownership at reduced capital cost, paired with a short out-of-the-money call to generate premium income identical to a traditional covered call.

The Poor Man's Covered Call is a capital-efficient options strategy implemented in the optionstratlib Rust library as a diagonal spread. By substituting a long-term equity anticipation security (LEAPS) for the underlying stock, this approach delivers the same risk-reward profile as a standard covered call while requiring significantly less buying power.

What Is the Poor Man's Covered Call Strategy?

The Poor Man's Covered Call is a diagonal spread strategy that mimics a traditional covered call without requiring the investor to own 100 shares of the underlying stock. Instead of holding the underlying, the strategy purchases a deep-in-the-money call option with a distant expiration date—a LEAPS option—and sells a near-term out-of-the-money call against it.

In optionstratlib, the strategy is defined in src/strategies/poor_mans_covered_call.rs and registered in the public strategy catalog via src/strategies/mod.rs. The implementation enforces the specific leg requirements that make the LEAPS-based replication possible.

How LEAPS Replicate Stock Ownership

The key to the Poor Man's Covered Call strategy lies in the delta characteristics of deep-in-the-money LEAPS options. Delta measures how much an option's price changes relative to the underlying asset's price movement.

Delta Approximation to 1.0

When PoorMansCoveredCall::new constructs the long leg (lines 8-16 of src/strategies/poor_mans_covered_call.rs), it creates a call option with a strike price well below the current underlying price and an expiration date typically 12-24 months in the future. Because this LEAPS option is deep-in-the-money, its delta approaches 1.0, meaning the option price moves nearly dollar-for-dollar with the underlying stock.

This delta behavior effectively replicates the price dynamics of owning 100 shares of stock, but at a fraction of the capital cost since the investor pays only the option premium rather than the full share price.

Capital Efficiency

The LEAPS leg requires significantly less capital than purchasing the underlying outright. While a traditional covered call on a $150 stock requires $15,000 in capital (plus margin requirements), the Poor Man's Covered Call might require only $5,000-$7,000 for the LEAPS premium, depending on the strike and time to expiration selected in the constructor.

Implementation in optionstratlib

The optionstratlib implementation enforces the specific structural requirements that make LEAPS-based replication work correctly.

Strategy Construction

The PoorMansCoveredCall::new method (lines 8-35 of src/strategies/poor_mans_covered_call.rs) constructs both legs of the diagonal spread:

use optionstratlib::strategies::PoorMansCoveredCall;
use optionstratlib::{ExpirationDate, Positive};
use rust_decimal_macros::dec;

// Create a PMCC for AAPL:
// • Long LEAP: deep‑ITM, 1‑year expiry
// • Short call: OTM, 30‑day expiry
let pmcc = PoorMansCoveredCall::new(
    "AAPL".to_string(),
    Positive::new(150.0).unwrap(),          // current price
    Positive::new(140.0).unwrap(),          // long LEAP strike (ITM)
    Positive::new(160.0).unwrap(),          // short call strike (OTM)
    ExpirationDate::Days(365.0),            // LEAP expiry (≈1 yr)
    ExpirationDate::Days(30.0),             // short‑call expiry (≈1 mo)
    Positive::new(0.20).unwrap(),           // implied vol
    dec!(0.01),                             // risk‑free rate
    Positive::new(0.005).unwrap(),          // dividend yield
    Positive::ONE,                          // 1 contract each leg
    Positive::new(15.0).unwrap(),           // premium paid for LEAP
    Positive::new(5.0).unwrap(),            // premium received for short call
    Positive::ONE,                          // open fee (LEAP)
    Positive::ONE,                          // close fee (LEAP)
    Positive::new(0.5).unwrap(),            // open fee (short)
    Positive::new(0.5).unwrap(),            // close fee (short)
);

This construction mirrors the unit-test validation found in tests_pmcc_validation (lines 71-88 of the source file), ensuring the LEAP strike remains deep-in-the-money relative to the underlying price.

Validation and Leg Requirements

The get_strategy implementation (lines 62-104 of src/strategies/poor_mans_covered_call.rs) enforces strict validation rules:

• Long leg must be a call with expiration significantly further out than the short leg
• Short leg must be a call with near-term expiration and higher strike price
• Side assignment ensures the long LEAPS represents the "stock substitute" while the short call generates income

This validation guarantees that the delta relationship between the LEAPS and the underlying remains sufficiently close to 1.0 to maintain the covered-call replication.

Break-Even and Payoff Analysis

The payoff profile of the Poor Man's Covered Call matches a traditional covered call exactly, as implemented in the update_break_even_points method (lines 54-58 of src/strategies/poor_mans_covered_call.rs).

Calculating Break-Even

The break-even point equals the long LEAP strike plus the net debit paid to enter the position:

// Inspect the payoff shape
let breakeven = pmcc.get_break_even_points().unwrap()[0];
println!("Break‑even price ≈ {}", breakeven);
println!("Maximum profit  ≈ {}", pmcc.get_max_profit().unwrap());
println!("Maximum loss   ≈ {}", pmcc.get_max_loss().unwrap());

This calculation accounts for the premium paid for the LEAPS minus the premium received from the short call, divided by the contract multiplier.

Profit and Loss Scenarios

The strategy exhibits three distinct zones identical to a covered call:

1. Below long-call strike: Maximum loss limited to the net debit paid (mimics stock falling to zero)
2. Between strikes: Profit increases dollar-for-dollar with the underlying rise, minus the net debit
3. Above short-call strike: Profit caps at the short-call strike price, matching the limited upside of a covered call

Summary

• The Poor Man's Covered Call uses a deep-in-the-money LEAPS option with delta approaching 1.0 to replicate the price movement of owning the underlying stock.
• This approach reduces capital requirements significantly compared to a traditional covered call while maintaining identical payoff characteristics.
• In optionstratlib, the strategy is implemented in src/strategies/poor_mans_covered_call.rs as a validated diagonal spread with strict enforcement of the long LEAP and short call relationship.
• The break-even calculation adds the net debit to the long-call strike, producing the same risk profile as a standard covered call position.

Frequently Asked Questions

What makes a LEAPS option suitable for the Poor Man's Covered Call?

A LEAPS option is suitable when it is deep in the money with a delta close to 1.0, typically requiring a strike price 5-10% below the current underlying price and an expiration date 12-24 months in the future. According to the optionstratlib implementation in src/strategies/poor_mans_covered_call.rs, the constructor enforces this relationship by requiring the long call strike to be significantly lower than the current underlying price while maintaining a longer duration than the short leg.

How does the capital requirement compare between a PMCC and a traditional covered call?

The Poor Man's Covered Call requires substantially less capital than a traditional covered call. While a standard covered call on a $150 stock requires $15,000 to purchase 100 shares (plus margin), the PMCC might require only $5,000-$7,000 for the LEAPS premium. The optionstratlib implementation reflects this efficiency by modeling the LEAPS leg as a synthetic stock substitute with delta approaching 1.0, delivering identical price exposure at a fraction of the cost.

What happens if the short call is assigned in a Poor Man's Covered Call?

If the short call is assigned, the trader must deliver 100 shares of the underlying. Since the PMCC holder owns a LEAPS call rather than the stock, assignment requires exercising the long LEAPS to obtain the shares for delivery, or buying shares in the open market. The optionstratlib validation logic in get_strategy (lines 62-104 of src/strategies/poor_mans_covered_call.rs) ensures the long LEAPS maintains sufficient intrinsic value and delta to facilitate this conversion, preserving the strategy's synthetic covered call structure.

How is the break-even point calculated for the Poor Man's Covered Call?

The break-even point equals the long LEAP strike price plus the net debit paid to enter the position. As implemented in update_break_even_points (lines 54-58 of src/strategies/poor_mans_covered_call.rs), the calculation accounts for the premium paid for the LEAPS minus the premium received from the short call. This results in a break-even level identical to a traditional covered call, where the position becomes profitable once the underlying price rises above the long strike by an amount equal to the net cost of the position.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}