Description
The covered call is the income strategy everyone learns first — and the one that quietly locks up enormous amounts of capital. The Poor Man’s Covered Call (PMCC) keeps the same payoff shape but replaces the 100 shares with a single deep-in-the-money LEAPS call, cutting the capital requirement by roughly 75%. In this post we build the structure from first principles, define the three rules that make it work, and implement the whole thing in Python — including the one risk check most beginners skip.
Introduction
A few months back I wrote about cash-secured puts and the Wheel — sell a put, get assigned, sell covered calls, repeat. It’s a clean, disciplined income machine. But it has one uncomfortable feature: to sell a single covered call on a $220 stock, you need to park $22,000 in shares. Capital efficiency is one of the three things I care most about, and a covered call is about as capital-inefficient as income strategies get.
So here’s the question a physicist asks: what part of the covered call actually generates the return, and what part is just collateral?
The return comes from two places — the stock’s delta exposure and the premium you collect selling the call. It turns out you don’t need to own the shares to get the delta. You need something that behaves like 100 shares. That something is a deep-in-the-money LEAPS call. Replace the stock with the LEAPS, keep selling calls against it, and you’ve built the same machine for a quarter of the cash.
That’s the Poor Man’s Covered Call. Cheap name, serious structure. Let’s build it properly — because done carelessly, it’s a great way to turn a “safe” income trade into a capped, decaying loss.
What Is a Poor Man’s Covered Call?
A PMCC is a diagonal call spread:
- You buy one long-dated, deep-ITM call (the LEAPS) — your stock substitute.
- You sell one short-dated, out-of-the-money call against it — your income leg.
- You repeat the short leg every cycle, collecting premium against the same LEAPS.
The long LEAPS gives you most of the stock’s upside (high delta) without tying up the full share price. The short call you sell each month pays you to wait, exactly like a normal covered call. The difference is purely capital: a real covered call costs you the share price; the PMCC costs you the LEAPS debit.
Two pieces, three rules. The rules are where the strategy lives or dies.
Rule Nr. 1. The LEAPS Must Behave Like Stock
The whole premise is that your long call substitutes for 100 shares. For that to be true, it has to move almost dollar-for-dollar with the stock. That means one thing: high delta.
I want a LEAPS with a delta of 0.80 or higher. At 0.85 delta, a $1 move in the stock moves the option ~$0.85 — close enough to behave like shares, while still costing far less than 100 of them. To get that delta, the call has to be deep in the money.
And it has to be long-dated — at least 12 months to expiration, ideally more. Two reasons: deep-ITM long-dated calls carry relatively little extrinsic value (so theta barely touches them), and a long runway means you can sell many short cycles against the same position before you ever have to roll it.
Here’s the delta math, straight from Black–Scholes:
import numpy as np
from scipy.stats import norm
def call_delta(S, K, T, r, sigma):
"""Black–Scholes delta of a European call."""
d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
return norm.cdf(d1)
S, r, sigma = 220.0, 0.04, 0.25 # AAPL ~ $220, ~25% IV
T = 1.25 # ~15 months to expiration
for K in [170, 180, 190, 200, 220]:
d = call_delta(S, K, T, r, sigma)
moneyness = "deep ITM" if d > 0.8 else "too shallow"
print(f"🎯 Strike ${K:>3} → delta {d:.2f} ({moneyness})")
Output:
🎯 Strike $170 → delta 0.89 (deep ITM)
🎯 Strike $180 → delta 0.85 (deep ITM)
🎯 Strike $190 → delta 0.80 (deep ITM)
🎯 Strike $200 → delta 0.73 (too shallow)
🎯 Strike $220 → delta 0.60 (too shallow)
The $180 strike at 0.85 delta is our LEAPS. Deep enough to track the stock, not so deep that we’re overpaying for intrinsic value we don’t need.
Rule Nr. 2. The Short Call Pays You to Wait
The short leg is just a covered call, sold against the LEAPS instead of shares. The selection rules are the same ones I use everywhere I sell premium:
- Out of the money, around 0.30 delta — far enough that the stock has to rally meaningfully before it’s threatened.
- 30 to 45 days to expiration — the sweet spot where theta decay accelerates.
- Sold when IV is reasonable, so you’re collecting fair premium, not crumbs. (See IV Rank for the filter I use.)
There’s one extra constraint that does not apply to a normal covered call, and it’s the rule beginners blow through. It connects directly to Rule Nr. 3.
Rule Nr. 3. The Net Debit Must Be Smaller Than the Strike Width
This is the non-negotiable one. Skip it, and you can build a PMCC that loses money even when you’re right about direction.
Think about what happens if the stock rips through your short strike at expiration. Your short call caps your gain at the short strike. Your maximum value from the spread is the distance between the two strikes — the strike width. If you paid more for the whole structure than that width, the cap is below your cost, and there’s no price at which you come out ahead.
So the rule is simple and absolute:
Net debit paid < (short strike − long strike)
where net debit = LEAPS cost − premium collected on the short call.
def pmcc_risk_check(leaps_cost, short_credit, long_strike, short_strike):
"""Confirm the diagonal can't be capped below its own cost."""
net_debit = leaps_cost - short_credit
strike_width = short_strike - long_strike
safe = net_debit < strike_width
print(f"💵 Net debit: ${net_debit:6.2f}")
print(f"📏 Strike width: ${strike_width:6.2f}")
print(f"{'✅ SAFE — width covers the debit' if safe else '🚫 UNSAFE — capped below cost'}")
return safe
# Our AAPL setup
pmcc_risk_check(leaps_cost=54.23, short_credit=2.10,
long_strike=180, short_strike=235)
Output:
💵 Net debit: $ 52.13
📏 Strike width: $ 55.00
✅ SAFE — width covers the debit
This single check is what separates a structured trade from a slow-motion accident. It also explains why the short strike can’t sit too close to the money: it has to stay far enough out that the width stays bigger than your debit. The cheaper your LEAPS extrinsic, the more room you have. Discipline upstream, safety downstream.
Concrete Example
Let’s walk a real setup end to end — same name I used in the cash-secured put article, so you can compare the two directly.
The setup:
- Apple (AAPL) trades at $220, in a healthy long-term uptrend.
- You’re neutral-to-bullish — you want upside exposure, but you also want to get paid while you wait.
- You have a $30,000 account and no interest in dropping $22k into one position.
Step 1 — Compare the capital.
def capital_comparison(stock_price, leaps_cost, contracts=1):
covered_call = stock_price * 100 * contracts
pmcc = leaps_cost * 100 * contracts
saved = covered_call - pmcc
print(f"🏦 Covered call capital: ${covered_call:,.0f}")
print(f"💡 PMCC capital: ${pmcc:,.0f}")
print(f"📉 Capital freed up: ${saved:,.0f} ({saved/covered_call*100:.0f}% less)")
capital_comparison(stock_price=220, leaps_cost=54.23)
Output:
🏦 Covered call capital: $22,000
💡 PMCC capital: $5,423
📉 Capital freed up: $16,577 (75% less)
Same directional exposure, same income mechanic — for 75% less capital. That freed-up $16k can sit in cash, back other defined-risk positions, or simply lower your concentration. This is capital efficiency in one trade.
Step 2 — Define the position.
# Long leg — the stock substitute
leaps_strike = 180.0 # deep ITM
leaps_dte = "~15 months"
leaps_cost = 54.23 # delta 0.85 → $5,423
# Short leg — the income
short_strike = 235.0 # OTM, ~0.22 delta
short_dte = "35 DTE"
short_credit = 2.10 # → $210 collected this cycle
net_debit = leaps_cost - short_credit
print(f"📈 Long ${leaps_strike:.0f} LEAPS ({leaps_dte}) cost ${leaps_cost*100:,.0f}")
print(f"📉 Short ${short_strike:.0f} call ({short_dte}) credit ${short_credit*100:,.0f}")
print(f"🔐 Net debit: ${net_debit*100:,.0f}")
print(f"🎯 First-cycle yield on capital: {short_credit/leaps_cost*100:.1f}% "
f"(~{short_credit/leaps_cost*(365/35)*100:.0f}% annualized)")
Output:
📈 Long $180 LEAPS (~15 months) cost $5,423
📉 Short $235 call (35 DTE) credit $210
🔐 Net debit: $5,213
🎯 First-cycle yield on capital: 3.9% (~40% annualized)
One short cycle pays ~3.9% on the capital actually deployed. Sell that call month after month against the same LEAPS, and the premium compounds against a position that cost you a quarter of the shares.
Step 3 — Read the payoff.
The chart at the top of this post shows the position’s P&L at the short call’s expiration — modeled with Black–Scholes, because at 35 days the LEAPS still has over a year of life and real extrinsic value (this is not a simple expiration diagram). Three things to notice:
- Below ~$218, you lose, but less than holding the LEAPS alone — the $210 credit is a cushion.
- At the short strike ($235), you hit maximum profit — the stock rose into your short call without breaching it.
- Above $235, the short call caps you. You still profit, but you give back the runaway upside. That’s the trade-off for getting paid.
Here’s the same thing as a scenario table:
# P&L at short expiration (LEAPS still alive, ~13.5 months left)
scenarios = {
190: -2242, # ⬇ stock drops — credit cushions the LEAPS loss
210: -730, # mild pullback
220: 103, # ➡ flat — roughly breakeven, you keep grinding
235: 1423, # ✅ max profit at the short strike
250: 1304, # ⬆ capped — still green, gave back some upside
270: 1209, # ⬆ capped — the cost of selling the call
}
for price, pnl in scenarios.items():
print(f"${price} → P&L ≈ ${pnl:>6,}")
Even in the “bad” upside case at $270, you’re still up ~$1,200 on $5,400 of capital. The structure does exactly what it’s designed to do: trade unlimited upside for a paid, defined, capital-light position.
Managing the Trade
A PMCC is not fire-and-forget. Two moving parts, two management rules.
The short call. Treat it like any premium sale: take profit early. I close or roll at roughly 50% of max profit, and roll out (and up, if the stock has climbed) when it’s tested. The one hard rule — never roll the short call down to a strike below your LEAPS breakeven. Doing that to chase premium can cap the whole position below cost and quietly recreate the Rule Nr. 3 failure you worked to avoid.
The LEAPS. Time is working against the long leg too, slowly. Roll it out to a later expiration when it drops under ~3 months to expiry, before the extrinsic decay accelerates. And if the stock has run far in your favor, the LEAPS delta keeps climbing toward 1.0 — at some point you’re holding something that behaves like stock with little extrinsic left, and rolling to a higher strike frees capital again.
The Internal Debate Before Every PMCC
The same three voices from every premium trade, tuned for this structure:
Greedy Brain: “Buy a cheap, slightly-OTM LEAPS — way less capital, and if it rips I make a fortune!”
Risk Management Brain: “A 0.50-delta LEAPS isn’t a stock substitute, it’s a directional bet that decays. And a near-the-money long means your net debit blows past the strike width. Rule Nr. 3 says no.”
Systematic Brain: “Delta 0.85, 15 months out, net debit under the width. Boring, structured, capital-efficient. That’s the trade.”
The edge, again, is in the filtering — done before the premium ever tempts you.
Final Thoughts
The Poor Man’s Covered Call isn’t a gimmick, and the cheap name undersells it. It’s a disciplined way to run the exact income mechanic of a covered call while honoring the third pillar I care about most: capital efficiency.
Three rules, and they’re the whole game:
- The LEAPS must behave like stock — deep ITM, 0.80+ delta, 12+ months out.
- The short call pays you to wait — OTM, ~0.30 delta, 30–45 DTE.
- The net debit must stay under the strike width — or you’ve built a capped loss with extra steps.
Get those right and you’ve turned $22,000 of dead collateral into a $5,400 position that does the same job and pays you monthly. The stock drifts up into your short strike? Maximum profit. It stays flat? You keep grinding premium. It pulls back? The credit cushions you, and you sell the next call a little lower.
Same machine as the Wheel. A quarter of the capital. That’s the whole point.
This is the mindset behind The Quantitative Edge — simple ideas, implemented cleanly, that scale into powerful tools for data-driven trading.
Statemi bene!
