Should I Trade Single-Stock Leveraged ETFs?
A single-stock leveraged ETF is based on an individual stock instead of a basket of securities. Unlike traditional ETFs, single-stock leveraged ETFs do not have built-in diversification. If you feel uncomfortable about managing a collection of individual securities that complement one another, then you should avoid single-stock ETFs in favor of traditional ETFs, such as SPY, QQQ, and DIA, which offer broad diversification.
Because many single-stock ETFs employ leverage, they are best suited for short-term trades during periods of rapid price acceleration. They can also be hazardous: daily resets, path dependency, and volatility decay can erode returns quickly when markets chop or reverse. This post demonstrates the use of the Proper Order and Gain Lock-in (POGL) model as a resource for taking advantage of the special trading opportunities offered by leveraged single-stock ETFs. You will see backtested evidence showing that the POGL model can systematically navigate the hazards of leveraged products while capturing the amplified gains they offer. By comparing model-driven trades in seventeen leveraged ETFs against trades in their unleveraged underlying securities, this post illustrates how disciplined signal selection can turn a structurally risky instrument into a targeted, opportunity-driven trading tool.
Tickers Tracked in this Post
There are thirty-four tickers tracked in this post. Seventeen tickers are single-stock leveraged ETFs, and the other seventeen are their matching underlying security. You can find how to download historical ticker prices for these tickers to either Excel or Sheets workbooks in the “Building Thirty-four Ticker Historical Price Datasets with Excel’s STOCKHISTORY and Sheets’ GOOGLEFINANCE Functions” post. The “How to Populate a Trading Database with Refinitiv, Excel, and SQL Server—Update 2” post presents a T-SQL script that can be adapted for migrating the historical prices from any Excel workbook to a SQL Server table.
The following table lists seventeen leveraged single-stock ETFs tracked in this post. Each ETF is identified by both its ticker name and its security name. A ticker name serves as a nickname or alias for the security name.
For a single-stock leveraged ETF, the security name reveals the ETF name, the leverage ratio, and the issuer of the ETF. For example, the first ETF with a ticker name of AAPB is
- issued by a firm named GraniteShares
- that depends on an underlying security with a ticker name of AAPL (Apple Corporation)
- and targets a daily return which is twice the underlying security’s daily change percentage.
The second ETF with a ticker name of AMUU is
- issued by a firm named Direxion
- that depends on an underlying security with a ticker name of AMD (Advanced Micro Devices, Inc.)
- and targets a daily return which is twice as large as the underlying security’s daily change percentage.
The next table lists the seventeen underlying securities for the leveraged single-stock ETFs in the preceding table. Again, each security is identified by both its ticker name and its security name. The ticker name for each underlying security appears in a matching single-stock ETF name. The daily percentage price change of the following securities is the target that is leveraged by the leverage ratio of its matching leveraged single-stock ETF.
For your easy reference, here is the final table for this section that shows the tickers for single-stock leveraged ETFs along with the tickers for their matching underlying securities. This table, along with the preceding two tables, can help you to follow the ticker-level and trade level results later in this post.
A Quick Introduction to the POGL Model
The POGL Model assesses when to buy a security based on a proper order relationship between specific Exponential Moving Average (EMA) values and their underlying closing price (where the closing price > fast EMA > slow EMA). This proper order relationship allows you to identify windows of generally rising prices.
At the time a security is bought, the POGL model sets an upper price boundary (greater than the buy price) and a lower price boundary (below the buy price). If prices continue to rise after a security is bought, the closing price will eventually exceed the upper price boundary, prompting the model to dynamically reset both the upper and lower boundaries. This process repeats as long as prices rise past each new upper price boundary. In this way, the model hitches a ride on a rising price trend for as long as it exists.
When the closing price ultimately falls below the lower price boundary, the security is sold at the opening price on the next trading day. On the day after a sell date, the proper order conditions for buying a security take effect again.
POGL Model Backtest and Summary Evaluation Code
The following T-SQL script demonstrates the application of the POGL model to the historical prices collected in the “Building Thirty-four Ticker Historical Price Datasets with Excel’s STOCKHISTORY and Sheets’ GOOGLEFINANCE Functions” post. Twenty-one and sixty-three day EMA values were computed and joined to the historical prices in the dbo.stockhistory_with_emas table, which serves as the primary data source for this backtest.
- Step 1 declares and populates the #ticker_map table, which stores the underlying and single-stock leveraged ETF tickers tracked in the backtest.
- Step 2 creates a fresh copy of the #proper_order_results temp table to store raw trade history results.
- Rows in this table are identified by their underlying ticker(u_ticker) and their matching ETF ticker(e_ticker) pairs as well as the buy and sell date for each trade.
- Recall that the backtest in this post applies the POGL model to the underlying price series and uses those buy and sell dates to designate start and end dates for the ETF historical prices. The backtest model does not apply the POGL model directly to the ETF historical price series.
- Given the buy and sell dates for each trade, the backtest evaluates the underlying and ETF return percentage values ( u_return_pct and e_return_pct) for each trade.
- The lockin_rungs column stores the number of rungs traversed during each trade. A rung is climbed each time a closing price exceeds the upper limit price boundary. Once a rung is climbed, both the lower and upper price boundaries step up to lock in trailing gains before the upward trend reverses.
- Step 3 executes the backtest via a pair of nested loops that tracks results by ticker pair and buy-sell dates for each trade implementing the core POGL model logic.
- The final two sections of the script calculate ticker-level performance metrics and trade level performance results.
/* 03_pogl_leveraged_vs_underlying_backtester
author: rick
dobson
purpose: execute
the proper order with gain lock-ins model (version 7)
across
the expanded 17-ticker matrix using underlying signals.
filtered down strictly to fixed-wager arithmetic performance.
*/
use securitytradinganalytics;
go
-- step 1: expanded mapping table for all 17 analysis
pairs
if object_id('tempdb..#ticker_map') is not null
drop table
#ticker_map;
create table #ticker_map (
u_ticker
varchar(10),
e_ticker
varchar(10)
);
insert into #ticker_map values
('aapl',
'aapb'),
('tsla',
'tsll'),
('amd',
'amuu'),
('amzn',
'amzu'),
('avgo',
'avgg'),
('baba',
'babx'),
('coin',
'conl'),
('crwd',
'crwl'),
('googl',
'ggll'),
('lly',
'llyx'),
('meta',
'metu'),
('msft',
'msfu'),
('mstr',
'mstu'),
('mu', 'muu'),
('nvda',
'nvdl'),
('pltr',
'ptir'),
('sndk',
'snxx');
-- step 2: global results table (stores finalized trade
history)
if object_id('tempdb..#proper_order_results') is not null
drop table
#proper_order_results;
create table #proper_order_results (
u_ticker
varchar(10),
e_ticker
varchar(10),
buy_dt date,
sell_dt date,
u_return_pct
float,
e_return_pct
float,
lockin_rungs
int
);
-- step 3: integrated loop logic (outer loop selects
asset pairs)
declare @u_tkr varchar(10), @e_tkr varchar(10);
declare cur_pairs cursor local fast_forward for
select
u_ticker, e_ticker
from
#ticker_map;
open cur_pairs;
fetch next from cur_pairs into @u_tkr, @e_tkr;
while @@fetch_status = 0
begin
if
object_id('tempdb..#u_data') is not null
drop table
#u_data;
-- [signpost:
real-world execution] - stage underlying data
-- look ahead
using lead() to capture the next day's open price for realistic execution fills
select
row_number() over (order by [date]) as row_id,
[date],
[open],
[close],
ema_21,
ema_63 as
ema_slow,
lead([open]) over (order by [date]) as nxt_o
into #u_data
from
dbo.stockhistory_with_emas
where ticker =
@u_tkr;
declare @i int
= 1, @max_i int = (select count(*) from #u_data);
declare @in_pos
bit = 0, @u_ent decimal(18,4), @b_dt date,
@low_b
decimal(18,4), @up_b decimal(18,4), @lvls int;
-- inner loop:
steps day-by-day through the asset's history
while @i <=
@max_i
begin
declare @d
date, @uc decimal(18,4), @ue21 decimal(18,4),
@ueslow decimal(18,4), @unxto decimal(18,4);
select
@d =
[date],
@uc =
[close],
@ue21 =
ema_21,
@ueslow
= ema_slow,
@unxto
= nxt_o
from
#u_data
where
row_id = @i;
-- state a:
evaluated when looking to establish a fresh position
if @in_pos
= 0
begin
--
[signpost: entry relationship] - verify proper order alignment
--
underlying close must be above 21 ema, and 21 ema must be above 63 ema
if @uc
> @ue21 and @ue21 > @ueslow and @unxto is not null
begin
set
@in_pos = 1;
set
@b_dt = @d;
set
@u_ent = @unxto; -- fill at
next day's opening price
set
@low_b = @u_ent * 0.95; -- initial
risk floor set at -5%
set
@up_b = @u_ent * 1.10; -- initial
target ceiling set at +10%
set
@lvls = 0; -- reset
active rungs counter
end
end
-- state b:
evaluated when tracking an active, open position
else
begin
--
[signpost: climbing the rungs] - the dynamic gain lock-in trigger
-- if
close exceeds the ceiling, scale up boundaries and increment rungs climbed
if @uc
>= @up_b
begin
set
@lvls = @lvls + 1;
set
@low_b = @up_b * 0.95; -- trailing
floor steps up to lock in profit
set
@up_b = @up_b * 1.10; -- target
ceiling steps up another +10%
end
--
[signpost: exit capture] - the trailing stop-loss trigger
-- if
close falls below the floor, execute the sell on the next day's open
if @uc
<= @low_b and @unxto is not null
begin
declare @e_ent decimal(18,4), @e_exit decimal(18,4);
--
look up matching entry open price for the single-stock etf
set
@e_ent = (select [open] from dbo.stockhistory_with_emas
where ticker =
@e_tkr and [date] =
(select [date]
from #u_data where row_id =
(select row_id + 1
from #u_data where [date] = @b_dt)));
--
look up matching exit open price for the single-stock etf
set
@e_exit = (select [open] from dbo.stockhistory_with_emas
where ticker =
@e_tkr and [date] =
(select [date]
from #u_data where row_id =
(select row_id +
1 from #u_data where [date] = @d)));
--
calculate raw percentage changes and write to the global results table
if
@e_ent is not null and @e_exit is not null
begin
insert into #proper_order_results values (
@u_tkr,
@e_tkr,
@b_dt,
@d,
((cast(@unxto as float) - @u_ent) / @u_ent) * 100,
((cast(@e_exit as float) - @e_ent) / @e_ent) * 100,
@lvls
);
end
set
@in_pos = 0; -- reset
state flag back to cash
end
end
set @i = @i
+ 1; -- move to
the next calendar trading day
end
fetch next from
cur_pairs into @u_tkr, @e_tkr;
end
close cur_pairs;
deallocate cur_pairs;
---------------------------------------------------------
-- reporting view 1: ticker-level performance (first tab)
---------------------------------------------------------
select
u_ticker as
[underlying],
e_ticker as [ss
etf],
count(*) as
[trade count],
-- simple
arithmetic summation representing the fixed-wager rule
cast(sum(u_return_pct) as decimal(18,2)) as [total summed u %],
cast(sum(e_return_pct) as decimal(18,2)) as [total summed e %]
from #proper_order_results
group by u_ticker, e_ticker
order by [total summed e %] desc;
---------------------------------------------------------
-- reporting view 2: trade-level performance (second tab)
---------------------------------------------------------
select
u_ticker as
[underlying],
e_ticker as [ss
etf],
buy_dt as
[proper order entry],
sell_dt as
[gain lock-in exit],
cast(u_return_pct as decimal(18,2)) as [u return %],
cast(e_return_pct as decimal(18,2)) as [etf return %],
lockin_rungs as
[rungs climbed]
from #proper_order_results
Performance Outcomes
There are two obvious ways to analyze the performance outcomes: by ticker and by trade. This section provides you a top-line view from both perspectives.Review of Ticker-Level Performance Results
- Each of the top five rows all have summed ETF % change values that are substantially larger than their matching summed Underlying % change values.
- Thee NVDL ETF ticker returned the top summed percentage change of more than 300%. Its percentage change value was more than 55% larger than its matching underlying ticker (NVDA).
- The second ETF ticker (MUU) more than doubled the percentage change of its matching underlying ticker (MU).
- Four of the middle seven ticker pairs have larger summed percentage change values for their ETF members than their underlying security ticker. All except one of the middle seven ticker pairs had positive percentage change values for their ETF ticker members.
- Each of the bottom five rows had negative percentage change values for their ETF tickers in contrast the top five rows.
- Additionally, the ETF ticker percentage change values for these rows were always negative.
- Furthermore, each of the ETF ticker percentage change values are always more negative than their matching underlying ticker percentage change values.
- The major takeaway from the following table is that ETF ticker percentage change values for the top five rows is massively more positive than the bottom five rows are negative. As a result, the table confirms that single-stock ETF securities are a winning trade relative to their matching underlying securities when traded with the POGL model.
Review of Trade-Level Performance Results
Some readers might be wondering what is the summed percentage change over for a ticker. The answer is that the sum is over the individual trades for a ticker. However, the POGL implementation in this post tracks trades by ticker pairs. Therefore, each pair member has the same count in the preceding table.
- Column headers appear in row 1.
- Rows 134 through 145 contain values for the MU and MUU tickers, and rows 146 through 168 contain values for the NVDA and NVDL tickers.
- The sum of E column values from rows 134 through 145 matches the Summed Underlying % Change for MU in the preceding table. Likewise, the sum of column F column values from rows 145 through 168 matches Summed ETF % Change for NVDL in the preceding table.
You can develop insights about how the POGL model
performs. For example, the following
table assigns green backgrounds to all trades with an etf return % column value
of 80 or more. The rows with green
backgrounds standout because of their high percentages. Although the POGL model was applied to
underlying security values, it does a superb for identifying trades with outstanding
ETF performances as well. Furthermore,
all of the green background rows have a rungs climbed column value of 4 or
more. In contrast, trades with a rungs
climbed column value of zero all have negative underlying security and ETF return
percentages. These outcomes confirm that
the rungs clumbed metric can reflecting rising price trends.
Within the #proper_order_results temp table, there are a
total of 217 rows for matching ticker pairs.
Each row represents a trade for the ticker pair on entry and exit dates
specified by the POGL model in columns C and D of the preceding
screenshot. The following screenshot shows
a scenario analysis where $10, $100, and $1000 wagers were placed on MU/MUU and
NVDA/NVDL for each of the 217 trades. Columns
C through G are hidden, and the cursor rests in cell P140.
- The expression in cell P140 is for the dollar change for the MUU ticker trade with start and end trade dates on row 140. This expression multiplies the ETF percentage change times 1000 to display dollar change for $1000 wager on that trade.
- The expression in O140 is for the dollar change for the MU ticker trade with start and end trade dates on row 140 and a $1000 wager.
- Cells L140 and M140 contain expressions for making a $100 wager on the underlying ticker and ETF ticker, respectively.
- Similarly, cells I140 AND J140 contain expressions for a $10 wager on the underlying ticker and ETF ticker, respectively.
- Comparable expressions are applied to the remaining trades within the I, J, L, M, O, and P columns of the worksheet image below.
This post’s final screenshot contains summarized dollar
change results for $10, $100, and $1000 wagers for underlying securities and matching
single-stock ETF securities across all 217 trades. I see
two issues supported by the screenshot.
- The collection of seventeen single-stock consistently outperformed their corresponding underlying securities no matter what the size of the wager by 43.38 percent no matter what the size of the wager.
- The dollar size of the change was directly related to the size of the wager. For example, the single-stock ETF trades increased by a factor of ten whenever the size of the wager increased by a factor of ten. This relationship also held for underlying securities.
Concluding Comments
The results in this post highlight a central truth about
single‑stock leveraged ETFs: they are structurally risky instruments that can
either magnify opportunity or accelerate loss depending on the timing of each
trade. Their daily resets, path‑dependent
behavior, and lack of diversification make them unsuitable for long‑term
holding and challenging even for short‑term discretionary traders. However, these same characteristics can become
advantages when paired with a disciplined, rules‑based model that identifies
rising‑trend windows and exits positions before reversals take hold.
When the seventeen matched ticker pairs are considered as a
whole, the POGL model demonstrated an ability to locate favorable entry points
in the underlying securities and to translate those signals into amplified
gains in their leveraged ETF counterparts. The model’s rung‑climbing mechanism proved
especially important. Trades with
multiple rung advances corresponded to the strongest ETF returns, while trades
with no rung advances reliably produced negative outcomes. This relationship reinforces the value of
using trend‑confirmation logic rather than relying on price intuition or
discretionary judgment.
Single‑stock leveraged ETFs are not inherently “good” or
“bad.” They are powerful tools that
require structure, timing, and risk controls to use effectively. The POGL model does not eliminate the risks
associated with leverage, but it provides a systematic framework for navigating
them. When applied to the underlying
securities rather than the ETFs themselves, the model captures the directional
strength needed for leveraged products to outperform by avoiding many of the
conditions that typically erode their value.
A practical way to interpret the findings is to view single‑stock leveraged ETFs as specialized instruments whose usefulness depends on how and when they are deployed. Their outcomes hinge on timing, trend strength, and the trader’s ability to follow a consistent, rules‑based process. The POGL model does not remove the structural risks associated with leverage, but it does offer a systematic method for identifying when those risks may be justified by the potential reward. By comparing each leveraged ETF to its underlying security across seventeen matched pairs, this post provides the evidence needed to evaluate whether a rules‑based approach like POGL aligns with your trading style, risk tolerance, and expectations. With that context, you can determine for yourself whether single‑stock leveraged ETFs merit a place in your trading toolkit.
Comments
Post a Comment