Trading Strategy Development: Simple Pullback Trading Approach

Traders can enhance their strategies by simplifying rules and adapting concepts through coding, fostering collective growth in trading skills.

### Strategy Development: Exploring and Coding a Simple Pullback Trading Strategy
* 📈 Welcome to a new YouTube series focused on investigating trading strategies found online, which will be **vetted through coding and testing**.
* 💻 The aim is to demonstrate practical coding techniques while inspiring viewers to **create and adapt their own trading ideas** to fit their personal styles.
* 🎓 Recently, the speaker participated in a mentorship program with Nick Raj, an experienced trader, and was inspired by his **insights and discussions on trading strategies**.
* 🔍 The video will specifically cover a **simple pullback trading strategy** presented by Joe Marwood, with the intention of **converting its rules into Pine Script for testing**.
* 📊 The strategy involves buying when the price **closes above the 200-day moving average** and **below the 10-day moving average**, with a **10% stop-loss rule** in place for risk management.
* 💡 The speaker emphasizes that while the strategy's **annualized return is around 7.6%**, it boasts a significantly **lower maximum drawdown of 12%**, making it **more appealing compared to a buy-and-hold strategy**.
* 🔄 The video also explores enhancing the strategy by adding an exit condition based on a lower close, which can potentially **increase the average trade profit** while maintaining a **high win rate**.
* 📝 The source code and links to the original video will be provided, encouraging viewers to **experiment with their own adaptations of trading strategies**.

Hi traders, welcome back to another video. Today I want to start a new YouTube series, and this series is going to be kind of a strategy development investigation kind of process where I'm going to go and find strategy ideas out on the web, on the internet. I know how

dangerous that sounds, but don't worry, we're going to vet these ideas using code and running trading ideas through the strategy tester. And the whole purpose of this series, series is one, I'm doing it anyway, it's something that I do in my spare time anyway, but two,

hopefully it will give me a good opportunity to show you guys, demonstrate to you guys some coding practices, techniques, concepts, um, that are practical that we can build on. And hopefully this series, these videos that I'm going to start creating over the months and probably years to come, will

help inspire you guys and motivate you guys to go and find your own trading ideas, convert them into code, adapt them to suit your personality, your personal trading style, and we can all become better traders together. Now, as mushy as that sounds, that's the whole

purpose of my YouTube channel and what I do here. I'm a trader, I want to get better at trading, why not share the journey with you guys and we can all get better together. And so without further ado, let's get into today's video. It's

going to be a bit of a longer one compared to the recent videos I've done, but I think it's going to be extremely valuable. Recently I've been going through a mentorship program with Nick, he's an Australian trader, quite well known. If you haven't heard of him, go and

Check out his Chat with Traders podcast episodes. They're brilliant. They have some really, really powerful trading ideas and lessons included in them. I'll leave links below in the description. This morning, I was just going through the forum here and reading up on some

trading system articles that Nick Raj particularly has posted. There's other students that post strategy ideas, but I'm always very interested in what Nick Raj finds interesting because he is such a great trader. I like to try to emulate his thought process in the markets. I have a very similar

philosophy on the markets to him. He's obviously far, far more experienced than I am. He's been trading for decades. I've been trading for maybe 5 years actively, but this post here caught my eye this morning. So Nick posted this video here

by um JB Marwood, the YouTube channel JB Marwood. Um, now I don't know anything about Joe, but I did watch this video today, and and I was really impressed by the concepts here. And so today I wanted to convert some of these ideas into Pine

script, show you guys how to build out a simple strategy script to test an idea, a trading idea in Pine. So before I get started, hopefully, Joe doesn't mind me doing this. Um, I'm obviously giving a shout out to his channel. Go and check it

out. There's some really cool trading ideas here, some really powerful stuff. Um, today I want to go over his simple pullback trading strategy and convert the idea, the rules into Pine. And when we're done, we'll get something like this. Now, my results aren't 100% accurate

compared to his results, but that could be because he's using different data than me. Um, he's using a different back testing software, but the results are similar enough and profitable enough to warrant investigating in Pine Script. So before I get started, I'll play a short

clip from his video just to um demonstrate the rules that he lays out. And again, when you uh finish with this video or even now if you want to, I'll leave a link below in the description to this video. I definitely encourage you to go and watch the whole video because

there's some really important ideas that are laid out in this video. But anyway, let me break down his rules. And again, hopefully he's okay with this. If you ever see this video, Joe, and you you're not happy with me um basically stealing your work, let me know and I'll take this

video down. Uh, but I just want to share this with my audience because I think this is really important information and an important template um that traders should be aware of. Traders, especially my experience, I obviously have a lot of traders come through my Mastery course.

Um, there's a lot of questions I get where traders are over complicating trading in a way that I feel is unnecessary. Trading does not need to be very complex in order for you to make good money out of the markets. And this strategy right here is a good example. So

let me skip forward to the rules here and I'll just play a quick clip from this video. So now let's look at the exact rules of this simple pullback strategy. So the buy rules, first of all, we're going to want a close above the

200-day moving average and a close below the 10-day moving average, so very basic rules. The longer-term trend is the 200-day moving average. We want to be above that, but we want to close below the 10-day moving average. So we've got a small pullback

within the longer-term trend. Now the sell rules are extremely important here. Um, we're going to we're going to sell when the close rises back above that 10-day moving average. So we're not looking for long-term trades here. We're just looking for

short-term trades, um, short pullbacks. And the other rule is we will sell if we get a 10% loss. So if we get a 10% loss, we're going to exit on the next bar open. Okay, we need some more settings, um, that we

can put into our back tester, um, so that we can run an accurate back test. So position size going to use just alright, I'll stop it here. I don't want to play too much of his work on my channel. Uh, again, go and check out this video if

you're interested. Uh, so the rules are incredibly simple. We're waiting for price to close above the 200-day moving average and close below the 10-day SMA, simple moving average. That's it. Buy rules couldn't be simpler. That's something I really love about Nick R's

work, um, in his books and his, um, videos online. He's a huge advocate for using simple and robust trading rules. He goes so far as to say that he doesn't believe that the entry reasons or entry criteria for strategies is a very important aspect of a trading

system there are other aspects of a trading system that are far more important um such as the overall concept of the system why it makes money um and obviously your exit reasons are super important and your money management risk management um approach plays a massive role in the profitability of any trading

system the entry criteria is one of the least important criteria it's not not important but it is one of the lesser important aspects especially when we're trading a robust system so this strategy is extremely simple we're waiting for the entry rules here and then the sell

rules are also very simple we um we're waiting for the the candle the bar daily bar this is a daily long early strategy by the way on the S&P 500 ETF that's what the strategy was designed to be traded on but it uh in my preliminary

testing it seems to be profitable on several other markets as well but anyway the sell conditions are once we're in a trade if price closes above 10-day SMA uh we exit our position we're just trying to capture small chunks of the overall long-term trend um the secondary rule is

that if price declines by 10% from our entry price or in other words we have a 10% loss on a closing basis we exit on the next bar's open uh we have a position size of 100% of our capital no leverage is used starting capital in this back

test is $50,000 commissions is 0.005 cents per share which is the Interactive Brokers rate and um execution is entering trades on the next bar's open which is luckily how the trading view strategy test to work so that's really easy to emulate in

today's lesson so let's jump into the Pine editor and start coding this into Pine code now before we do that I should probably mention the um overall metrics of this system according to Joe's back testing using AmiBroker which is a much more powerful strategy tester system

than TradingView but it's also much more complex um I might consider exploring AmiBroker code in future lessons if you guys are interested in that I'm learning how to code in AFL the um programming language for AmiBroker it's a it's a it's a very powerful

program but it is also much more complex than Pine there's pros and cons to that the pros are that you can do very extensive statistical analysis of your strategy results over historical data the cons are it's expensive you need extra data so data from a data provider

and the code is is just harder to learn compared to Pine but anyway that's IR relevant for today's video so the metrics here have a decent annualized return um but it is less than Buy and Hold so Buy and Hold Returns on average about 10% per year on the S&P 500 this

strategy returns about 7.6% so it's less profitable than just simply buying and holding the SPY ETF however look at our maximum drawdown the Max drawdown of just holding the S&P 500 ETF is 55% of your capital so

you lose over half half your capital by just doing nothing and holding the ETF but you do make about 10% per year which is okay uh but this would make a lot of investors uncomfortable and I'm sure a lot of traders and investors would sell

as you near that max drawdown and then that will affect your annual return negatively and so there's a lot of psychological reasons why Buy and Hold is not a good strategy despite the fact that it does have a 10% return on average per year whereas this system has

a slightly less return, but look at the max drawdown, 12%. I would take a max drawdown of 12% any day of the week on any strategy that is well within my risk tolerance and so that's kind of the idea

of this strategy, it has a much better risk-adjusted return than Buy and Hold and it also has a very high win rate, 75% win rate is pretty impressive. Now to achieve that win rate, it doesn't make a lot of money on each trade, so half a

percent per trade, but its edge is in its win rate. So this is a strategy where the win rate plays a major part in its profitability. Um, I usually trade strategies that are the opposite, so the risk-reward profile is what accounts for the profitability rather than the win

rate, so I can trade strategies with 40, 45% win rate, but with a high risk-reward and that is how I tend to make my money, whereas this strategy is kind of the opposite. We're taking small wins, but very frequently. Anyway, let's jump into

the Pine editor and code all of this into Pine. All right, so here we are with a blank script, a relatively blank script. All I've done here is input my default strategy parameters, so we have overlay set to true, so we're drawing over price action, our initial capital is set to

$50,000. Our default quantity type for this strategy is set to percentage of our equity, and our quantity value is set to 100% of our account balance. So, on each trade we get involved with, we're trading 100% of our account balance with

no leverage. Our commission type is set to cash per contract, and the commission value is set to 0.005 cents per share, which, as I mentioned earlier, is Interactive Brokers' commission rate. And Interactive Brokers is probably one of the most common, if not the most common,

stock trading platform. And so that's why we're using this as our default parameters. Now, if you've watched my previous video on the latest update to TradingView's strategy tester, you'll know that they've recently added this uh bar magnifier setting. And I said in that

video that we should always turn this on on every single script we write. Now, that is true, but only on scripts that have a stop-loss and take-profit, like a fixed stop-loss, fixed take-profit, or entry limit orders. Um, for a strategy that operates solely on candle closes, it's

not necessary because there is no risk of intra-bar price action negatively affecting our backtesting results. If you're not sure what any of that just meant, make sure to go back and watch the previous video on this channel about the latest uh strategy tester update. Oh,

leave a link to that in the description as well. So, we don't need bar magnifier for this particular strategy. Let's move on to getting our user inputs. So, to save time, I'm just going to copy and paste some code I've already written because

it's not important how the user input code is written but we need several inputs here so we need two moving averages one is the 200 SMA the other is a 10 SMA 10 period SMA so a long-term and a short-term moving average the second or

third parameter here is our stop-loss percentage so by default that's set to 0.1 or 10% so if price declines 10% from our entry we exit our position so that's basically a fail-safe stop loss so if price never closes back above the 10

period SMA we can still exit our trade for a loss to cut our losses short instead of letting our losses run too far the final inputs here are just a start date and an end date filter these are used for analyzing in-sample and out-of-sample periods um I'm not going to go

into too much detail about statistical analysis of our back testing results in this video because it will make this video way too long that's a subject that deserves its own series let alone video and maybe I'll cover that in the future if you guys are interested in it I'm no

expert on that stuff I'm not very good with mathematics to be perfectly honest with you guys but I am learning a lot about this stuff through Nick Rager courses and so in the future I will probably record uh lessons on this super important subject of deep and robust

back testing processes but for now we'll keep things as simple as possible and just focused on the Pine code so today's lesson is just an example a strategy example how to code a really simple concept into code into Pine code and then test that theory in a simple but

quick manner the next thing we need to do is get our indicator values so again I'll just paste this code to save time it's really simple we're just getting two moving averages two SMAs using ta.smma both based on the closing price

source price source and one with a 200 one with a 10 period now I need to replace these with our inputs so that we can adjust these moving average lengths in the settings menu uh if we want to so now if I save my code we should have

these settings up here there they are and they have little tooltips explaining what each setting does this is completely optional I'm only doing this because this is a YouTube video script and I want you guys to fully understand what each user input does now

now next thing we need to do is get our date filter so again I'll paste that code in really simple here we're just checking if the current bar's time is greater than or equal to our start date and time and is the current bar's time

less than or equal to our end date and time so this allows us to filter what trades get taken based on a date period now we get to the juicy part where we check our buy and sell conditions so remember the rules are really simple um the first thing we need to do before

I get to the rules is save our buy price so I'm just going to initialize a persistent variable V variables mean that they don't reset on every single bar it's a float type so it's a number type with a decimal place and it's going

to be set to zero by default on the very first bar on our chart and then we'll obviously overwrite this with our buy price when we enter a trade that way we can actually calculate our stop loss that 10% decline from our buy price so

that we can exit trades that go against us now our buy condition is the closing price greater than our ma1 which is our long-term moving average the 200 period moving average and is the closing price on the current bar less than our short-term

moving average or the 10 period moving average those are our basic entry conditions but we also need to make sure that we're not already involved in a trade because this strategy does not include pyramiding so we want to check is our position size equal to zero if

it's equal to zero we're flat and we want to check our date filter so I'll throw in the date filter here this just checks if the current bar falls within our two time periods and that's it for our buy conditions um now before I continue let's draw some pretty

colors onto the chart um and by that I mean our moving averages so we're going to plot our ma1 and ma2 onto the chart save my script and now what we're looking for is price to be trading above the 200 period moving average and close below the 10

period moving average and then we buy on the next bar's open and we sell when price closes back above that 10 period moving average or price declines by 10% that's it that's all we're looking for so let's finish coding this out we have

our buy condition next up we need our sell condition and that remember is just is the closing price greater than our short-term moving average or MA2 let me indent these a little bit to make it easier to read the second condition for selling is that we are

currently involved in a trade so to check if we're involved in a trade we just check if position size is greater than zero that means we have open contracts and that's it for our basic sell condition the next thing we need to do is uh check our stop loss so our stop

loss remember uh I'll start with calling it stop distance and stop distance is going to be set to and now this is completely optional what I'm about to do next it does make the code a little bit more difficult to read but it will make

our plots easier on the eyes when I'll show you what I mean in a moment but what I'm going to do is check is our strategy.position size greater than zero question mark if so if this condition is met then we want to calculate our Buy

price minus the closing price divided by the closing price this will give us the stop-loss distance as a percentage on the current bar so this will calculate the percentage decline from our entry so let's say we entered on this bar here I'll put a horizontal line there that

red line this code here will calculate the percentage decline from this red line on each bar on our chart on a closing basis so each bar that closes below this red line um this code will calculate this number here 6.53% or minus 6.53% this will calculate this as a

positive number, so in this case, it would be 6.53% - 6.53%, and we use that to check our stop loss. But before we do that, the next thing I want to do is calculate our stop loss price. So that's going to be again

is our position size greater than zero, so are we involved in an open trade? If so, we subtract our Buy price from our Buy price multiplied by our stop percentage. So this is our stop loss percentage. Again, by default, it's 10% or 0.1.

So this stop price will calculate again using this red line as our Buy price, the stop price will be by default 10% below this line, so all the way down about here at 1 uh 42 1.45 is. So that's our stop loss if we entered

on this bar here, our stop loss is down here, and if we never get a bar that closes above this short-term moving average but price closes below this uh red line, then we exit our trade for a loss. That's our stop loss. And then finally, the final thing we need to write

out here for our buy and sell conditions is our stop loss condition itself, and for that again, we check is the position size currently greater than zero, so we're involved in an open trade, and our stop distance, so the current decline on a closing basis on a percentage basis from

our entry price is greater than our I, and I stands for input, so input stop percent, then that means price has declined by our stop loss percentage point, and we need to exit our trade. That's it. Now I know I went over that pretty quickly, but I'm trying to keep

This video is relatively short, you can always slow down the video or watch this a couple more times if this went over your head. Um, but this is all we need to enter and exit our trades. The final thing we need to do is actually tell the strategy tester when to enter and when

to exit, and that's actually really simple. So for enter positions, we're going to check if by, whoops, by condition. Remember, Pine is case-sensitive, so if by condition is true, then we use the strategy.entry function to enter a trade. We need to give it an ID, so I'll just call this

long, where long only, remember this is a long only strategy. I believe this kind of strategy is called a long beta strategy, so we're just trying to capture long only returns out of the market, and in this case, we're not even trying to beat the market. We're just trying to

beat the market's max drawdown while maintaining a decent return, annual return. But anyway, the next thing is a direction. We need to tell the strategy tester which direction we want to enter our trade today. We're long early, so we just set that to strategy.long. That's

it. We're entering our trades based on our buy condition. Now the next thing we need to do is save our buy price so that all of this code here can actually be calculated. So so far we haven't actually saved a buy price. We do that obviously

after we've entered a trade. So we need to put that code below our buy condition now because we are entering on the next bar's open after the signal or the condition is met. So once our buy condition is met, the strategy tester, let's use this candle right here as an

example again so here we get a confirmed entry we're above our 200 period moving average we just closed below the 10 period short-term that's our entry criteria met on this bar that criteria gets met but the strategy tester won't enter our trade until the next bar's open

which will be about here so when we save our Buy price we don't want to save the um signal candle closing price we want to save the next Bar's open price as our Buy price so to do that we can just check if we had a

buy condition on the previous bar so if buy condition on the previous bar is true then we save our Buy price as the current Bar's opening price and now we have our Buy price saved and all of our metrics here will be calculated properly and that's it for our entry conditions

the next thing is to check our um exit criteria to do that really simple we just check if Cell can do so if we have our standard take-profit sell condition uh which is that the current bar closed back above the 10 period moving average so here for

example we're trading above both moving averages and then we get a close below the 10 period SMA we would enter long right here we would hold our trade until price closed back above that 10 period moving average and then we would sell on the next bar's

open so that's what our sell condition is but we also have our stop condition remember so that can also be combined with our sell condition so if we have or sorry or if we have a sell condition or a stop condition then we want to exit our trade and to do that we can simply

use the strategy.close function, we need to tell it which, um, order to exit. In this case, that's our long order, so we're exiting our entry ID of 'long' on this function here. And to make it clear when we exit for a profit or for our stop

loss being hit, I'm going to add an optional parameter here which is our comment. And the comment is just going to say 'exit'. So normally it will just say 'exit' if we close our trade. However, I'm also going to add on a conditional statement here that will say 'if' and let me make

some, some more room here. If we had our stop condition met, then add-on 'SL=true'. So this is text that's going to display on our chart and it just simply says 'stop loss equals true'. So we exited our trade because our stop loss was hit. Otherwise, add nothing to

this string because we don't really care. We don't, this will just differentiate between trades that close back above the 10 SMA and trades that close below our 10% decline from our entry. That's it. The final thing I'm going to do here is just

overwrite our buy price to 'na'. This is purely for drawing purposes. We'll get to that in a moment, but now there's only two more lines of code to write and our script is completed. And that is, I'll just copy this code over to save

time. It's just two more plots. So we're going to plot our buy price onto the chart so that we can see when the script bought, which price it bought at. And we're going to plot our stop loss onto the price so that we can see where the

script will exit our trade if price declines beyond our stop-loss and I set the offset on our stop loss to minus one because the way we've written our code up here it won't actually draw the stop-loss until we've been in the trade for

one bar so we want to shift our stop loss line back one bar so that the two lines are drawing in sync so I'll show you what I mean if we save my code here hopefully this compiles without any errors and there we go it definitely did

not so where is our error it's on line 30 I didn't finish our conditional statements here so for these two statements we're just going to add 'na' on the end so our stop loss distance if we are not involved in a trade our stop distance is going to be

set to 'na' so that we don't draw anything onto the chart so here stop price is set to 'na' when we're not involved in a trade if we don't do this um we'll have lines drawing all over our chart even when we're not involved in a trade we don't

PINE SCRIPT: 75% Win Rate on a Simple Pullback Strategy

The Art of Trading

Introduction of a new YouTube series focused on strategy development.

Announcing a new series investigating and developing trading strategies from online sources.

Strategies will be vetted using code and a strategy tester.

The series aims to demonstrate practical coding practices and techniques.

Goal is to inspire viewers to find, code, and adapt their own trading ideas.

Discussion of a simple pullback trading strategy from JB Marwood's YouTube video.

Mention of a mentorship program with Nick, an Australian trader.

Discovery of the strategy through Nick Raj's forum post.

Introduction of JB Marwood's video featuring a simple pullback strategy.

Intent to convert the strategy's rules into Pine Script.

Comparison of backtesting results with JB Marwood's.

Explanation of the simple pullback strategy's rules.

Buy rules: Close above the 200-day MA and below the 10-day MA.

Sell rules: Close above the 10-day MA or a 10% loss.

Emphasis on the simplicity and robustness of the trading rules.

Importance of exit rules and risk/money management over entry criteria.

Setting up default strategy parameters in the Pine editor.

Adding user inputs for moving averages, stop-loss, and date filters.

Getting indicator values (moving averages) using ta.smma.

Implementing date filter to control the backtesting period.

Defining buy and sell conditions based on moving averages and stop-loss.

Visual demonstration of the strategy's performance on a chart.

Strategy tester metrics: net profit, max drawdown, win rate, etc.

Discussion on improving the strategy by adding a lower close exit condition.

Adding a user input for the lower close exit condition.

Analysis of the impact of the lower close condition on trade outcomes.

Recap of the strategy development process: finding ideas, adapting them, and testing in Pine Script.

Importance of adapting strategies to personal preferences.

Concluding remarks and thanks to viewers.