Trend and Momentum Bot

So again, welcome back to the bot workshop. This week we're gonna be doing a Trend and Momentum Bot for Stocks. So this week, here's what are we going to be talking about on this bot workshops. So this bot workshop, we're gonna be focusing, like I said, on this “Trend and Momentum bot.”

So it's a little bit of a different variation of the bot that we had done previously. So last week, we did just a very simple swing trading bot. Now we're gonna do a bot that uses very simple trend and momentum. Again, we're gonna give you just two examples of how you can do this. You can obviously create your own version of this, and then you can post it to the thread that we'll add at the end of this.

We can all share about templates back and forth with one another. But the goal for this bot templates are couple things; one, we're gonna use a combination of technical indicators to scan for a long equity position. So again, this is a very beginner bot template, a very simple one that you can start with and then you can build on from here.

The next thing that we want to do is we want to ensure that technical readings are also not "too hot" using some and decisions. This is going to be a little bit, a little bit more of an advanced feature inside of this beginner template, but I think you'll understand the logic when we get to it.

We wanna make sure that these readings are good, but in one case with the momentum one, we wanna make sure we avoid things that might be judged as being "too hot" or "too high" of momentum.

The third thing that we want to look for is we want to look for a monitor automation with management decisions for multiple exits based on technicals, profit targets, or some sort of stop-loss. We'd do a very similar thing as what we did last week, and finally, we're gonna be using custom inputs throughout because they really are the best thing that you can do to create custom variable fields inside of your bots which allow you to add multiple scanners with one or two little ticker variations or other things inside of the bot that can be variable fields for you as you go. Okay? Does this make sense?

So we're gonna be doing this today; we're gonna be taking our time to make sure we build out this bot. Again, my sole focus is on building out this particular template as we go.

First thing that we're gonna do is we're gonna just go up here to create a brand-new bot template or a brand-new bot. We're gonna name this something like "Kirk's Trend + Momentum bot." Again, you can name it whatever you want.

You set the allocation; this is the max allocation that you're gonna give the bot. This means that at this point, any time that the bot enters positions, it will know it will stop entering positions when it's reached its max allocation. So if it has one position, and that position is $5000, it stops. If it has two positions that it's allowed and each is 2500, then it stops.

Next thing that we're gonna do is we're gonna set some position limits. I'm gonna keep these ones at one and one for right now. It's a very beginner bot. All I'm looking to do is getting to a long equity position when we get trend and momentum at the right direction and then exit the long equity position. So I can set the max limit for one position per day and one position at any time. So that's how I am set. I am gonna create, and I am gonna view my bot shell.

So the first thing that we have to do in building this out we have to build out our automations. So if I go over to my automations tab, I want to first build out my scanner. Now, remember, the scanner is where we tell the bot what decisions to make, what actions to take, etc., that would lead to a new position.

So scanners are basically your little bot workers that go out there and filter throughout the data and make all the decisions for you that lead to a new position. So we're gonna add a brand new scanner, we'll just click this little plus icon right here, and then we select from our drop-down list.

Now, in this case, we can always choose from something that's already in our library. We can sort and organize these. You guys have seen this before. We're gonna create a brand-new automation, and in this automation, we're gonna call this our "Trend + Momentum Scanner for Stocks."

Again, the way that I like to do this, you can do it however you want, it's your choice. The way that I like to do this is I like to be very specific with my names for automations. I like to tell it what it is like, what type of thing it is, is it a scanner, is it a monitor, right? Because I can use them in different places. You can use them for buttons. I can create a button that, you know, runs this scanner later.

So I like to be very specific with my naming, so I know exactly what it's doing, and I can always jump back in here and check it at any point. So that's the first thing I am gonna do; "Trend + Momentum Scanner for Stocks."

The next thing that I wanna do is I want to add my first decision. Now, before I get into this, let's talk holistically about what we're trying to do here. We want our bot to monitor for two different things as we build this out.

The first thing that we want our bot to look for is a stock that is in an uptrend. We're gonna judge an uptrend as a stock price being above its 200 day moving average. Now again, create a variation of this, create a different version of this, post it to the community when we get done at the end, and get yourself some votes and help each other out in the community.

But for now, we'll keep it very simple; stock price being above the 200 day moving average. That's the first thing that we wanna see in order for us to execute a position.

The second thing that we want to see is we wanna see the stock having some strong momentum. Today we’re gonna judge strong momentum with ADX. We’re gonna judge an ADX reading above 20 as suggesting that the stock has strong momentum. Again, you can have 25; you can use 18, whatever you want. But for us today, the example we’re gonna use is ADX reading above 20.

So, stock price above the 200 day moving average, ADX reading above 20. You can also substitute RSI and say RSI above 50 or RSI above 60. Whatever you want to do, you can do it here. We’ll use ADX, and then you guys can create versions from that.

So first thing we do is we click the plus icon, and we want the bot to start making decisions. This means that we want the bot to start going through every time it’s looking for an opportunity to get into a position start going through the decisions that we just outlined.

Well, the first one that we’re gonna include here is this one; symbol price above some moving average. So we select this, and now we can fill in the actual symbol. We can type in and fill in SPY, and that means that every time that we go through this, it’s gonna use SPY.

Now that’s fine if you know that you always want to use SPY, but what if we want to create a more flexible field? We want to create something that’s variable. So maybe sometimes we want to use SPY, maybe sometimes we want to use EEM, or TLT, or whatever it is.  

So instead, what we do here is we click on this little blue, blue icon, and that creates the ability or gives us the ability to add a custom input. So custom input is great because what it does is, it creates a variable field right inside of the automation. It allows you now to reuse the automation over and over and over again across all kinds of bots and swap out these inputs for whatever variables or fields you want, or in this case, ticker symbols.

So we’ll just label this to something like “Ticker Symbol” or whatever you want to call it or call it whatever you want. And then, we’ll set a default symbol. We’ll set the default as SPY and then click save.

Now when we do this, you’ll notice that instead of SPY showing here, it actually shows the label that we created, in this case, “Ticker Symbol.” So the ticker symbol that we set, which will set later, and once we save this automation, we can set these, the ticker symbol price is above, and then we’ll switch this from a 30 day to a 200 day moving average. Again, you can use a couple different variations of averages in here. Once we’re good to go with this, then we hit save.

Now we could just save this, and that would add that decision to our automation editor that now splits our tree into the yes and no path. But I wanna do something a little bit different instead. Instead, I wanna go back in here, and I wanna add another decision because when it gets to this decision block, I want the bot to check a couple things before it goes down the yes or no path.

So instead of splitting them up like what we’ve done previously, I’m gonna add another decision right here to this one particular block. And then I’m gonna go all the way down to our list of indicators, and just like this top on here which is symbol above or symbol 14 day indicator is above or below some value.

Now I’m gonna select the symbol, again you can select SPY if you know you always want to do SPY, or because we’ve already created a custom input that is for a symbol field, we can link to that symbol field by just selecting the custom input icon and then clicking on that ticker symbol field we already created.

Now, this is really cool because what it does now is it uses one input for a symbol, and that symbol inputs flows over throughout the automation. Next thing that we’re gonna do is we’re gonna check and see if the 14 day ADX reading is above some value. Now, this is where it’s gonna be really, really fun, okay? This is where it’s gonna be really, really fun.

The 14 day ADX reading, in this case, is above 20. To us, for this example, that would tell us that in this case, the trend is strong or strong judged by a reading above 20. You could use 25 or whatever you want, 18 doesn’t matter, but something around here would be a decent signal for ADX for a trend, or I’m sorry, for momentum. So we already have trend with a long-term moving average, now have ADX as a judge of momentum.

Now, if we input 20 here, that’s fine. That means that it’s always gonna stay at 20. But if we want that field to be variable which we do in this case, then what are we gonna do? We’re gonna create a brand-new custom input. So we’re gonna add a brand new custom input, we’re gonna call this “ADX Lower Bound,” that’s basically- we’re gonna call this “ADX Minimum,” right? So we want ADX to be above this minimum reading of 20. We’ll set the default to 20, but we can change it anytime that we want, and we want to use that as a custom input.

And the reason we want to use this as a custom input is because later when we add a different ticker to this bot, we had multiple tickers, we might wanna change the ADX reading to 25, and we don’t want to have to change the automation as we go. So we’re gonna set this one to 20. Again when we click off over there, you can see that the new ADX reading is in there. It says it’s above ADX min. So now we have another decision inside of our big fat decision block that we’ve created in here, right?

So now you can see when you save it; now you have all of your decisions getting so much in here. So when we go through this particular set of decisions, we now wanna check and see if the ticker symbol is above 200 day moving average, and we wanna make sure that the ticker symbol’s 14 days ADX reading is above the ADX minimum.

So the one thing that we wanna add that I mentioned in the slides earlier is we actually wanna add, yet again, another decision. We wanna add another decision here, and we wanna check and see if ADX is actually lower than some high threshold.

So just like when you’re trading RSI, right? Or using RSI. Maybe you wanna trade when RSI is in a certain range, but you don’t wanna trade something when RSI is 100 and you wanna, you know, buy the stock, right?

So here, we have an opportunity to specifically define and tell the bot; look, we want ADX to be above some minimum threshold and below some maximum threshold. Where if ADX is really, really high, we actually maybe wanna pass on the trading opportunity. Maybe the trend or the momentum is getting overextended, right? Maybe that’s the case.

So you can do this a couple different ways. You can use moving averages; you can use crossovers; you can use a bunch of different things. We’re gonna use, in this case, just another ADX recipe. So we’re gonna again link up our ticker symbol field. We’re gonna change this to ADX, and now we’re gonna say we want the ticker symbol to be below some value.

Now here we’re gonna create a new custom input. We’re not gonna use ADX minimum. We already use that one for a minimum threshold. Now we’re gonna create a new variable called “ADX Max,” and maybe we set this at something like 30, okay? Whatever you want to set that, you can set that as 30, 35, whatever you want, right? So 25 might be too close, but maybe 30 like anything above 30 that’s way too far, now we don’t want to do that.

So now we hit save. We add this to our list of decisions, and now we have three very specific decisions. All of these decisions have to be true in order for the bot to continue down the yes path. Does that make sense?

So as soon as the bot starts running, it’s gonna first encounter this massive decision block. We’re telling the bot, look, check for these three things and only if these three things are all true, then do- I allow you essentially to continue down the yes path.

Make sure the ticker symbol’s price is above 200 day moving average, and make sure the ticker symbol’s 14 day ADX reading is above our minimum, which might be 20. And at the same time, make sure that the ticker symbol’s 14 day ADX reading is also below the max. So it’s aggressive and strong momentum, but it’s not too hot.

So we go ahead, and we save, and now we have this big block of decisions. Now notice on the left-hand side here we also have some of our inputs that are now showing up. So we know that we have a ticker symbol input that’s being used three times. An ADX Minimum that’s used once, an ADX maximum that’s used once.

Again anytime that you want to go in and edit these, you just click the gear icon, you select the actual label input, you can make any of these changes in here, and then you save and dump out there, and you’re good to go.

So once we go through this now, we only have one other thing we need to add. And now we’re gonna add the actual action to open a position. So if all of this was true, then we wanna buy long stock and whatever ticker symbol we’re looking at. To us, we’ve judged that all of those things are needed to get into the position; now, we add an action to open a position.

We’re gonna open a Long equity position. We’re gonna select a symbol here. Notice you can select the symbol manually or because we’ve created that really, really, really sweet custom input. We can just link it to that existing custom input called Ticker Symbol, and we can set the amount.

Now you can go and play with this and do all kinds of different amounts or allocation, you know, percentages, and things like that, but for here, we’ll just keep it really simple and do just one share. So I saved this, and now we’re good to go.

Now we have our complete scanner built out. That’s very simple; only two actions are in the scanner, but inside of the decision action are multiple different decisions that the bot is gonna go through every time.

The cool thing about using the automations here is we can just now test this particular scanner right inside of the automations. So we can go here to the test button. We can put in a symbol that we want to test, like ticker symbol SPY. We can put in some readings, and then we can start the test. And this will tell us that if this was actually turned on and live running with that data where it would actually fall in the actual scanning process.

Here you can see only two of these things actually one was true, and then the other one failed. And it didn't even get to the other one cause the first one failed, which it kind of nullified the whole thing anyway. So the ticker symbol was above its 200 day moving average, but the 14 day ADX reading was below 20. Done, stop, out, right? Now you're good to go.

Now you know that this thing works, you can test other symbols in here if you want to, so you can say, "Okay, well, let me test GLD. I want to see what the reading is gonna be on GLD." Notice on GLD, two of the decisions were true, but it failed on the last one. So now it was too high. The reading on ADX was overdone, and if you see a chart of DDX or GLD right now, you probably realized that it had a quite a big move, so it might have kept you out of getting into a position at just the wrong time. Okay?

So you don't need to do anything here. Once you're good to go with this, you have everything built out the way you want, you simply exit out the editor, and now you get into the last screen where you save your scanner. Remember, we select a new automation here cause we built it from scratch. But now that we've added some custom inputs, basically, a screen comes back up, and it says, "Okay, look, you have some of these custom inputs. Do you wanna confirm that these are the values?"

Now here's where you actually might change these values. You might change this instead of SPY; it goes to GLD. Maybe you changed the minimum to 21 and the maximum to 31. Whatever you do here, you can make those changes and then simply hit save. Once you hit save, that now adds the scanners to your list of scanners. Now here's why it's really cool to use custom inputs. Because in this particular case, if you hover over here, you can see that this scanner running on GLD and has the readings that we show here for the ADX min and max.

But if we wanna add another scanner to our list of scanners, we wanna do another stock instead of an index. Yeah, sure, we want to do another stock, maybe APPL. We can go here to add another scanner we select from the dropdown list. The bot is smart enough to recognize you already have the scanner that's in here, and it says, "Hey, do you wanna use this scanner that's already in your bot?" Sure, I wanna use that one again.

Now I wanna change the inputs for this scanner, and I wanna do something different. So I wanna do APPL, and I wanna do the minimum for APPL is 15, and the maximum is 25. Then I click save, and now that's added to our list. And now I have the exact same automation running, but because I have custom inputs, the actual variable fields inside of you automations that run; the ticker symbol, the ADX min, and max are gonna be different for different ones. In this case, we have GLD with these settings, and now we have APPL with these settings.

So, in this case, we didn't clone the scanner; we're just reusing it. So if I wanna add another one, let's say we wanna trade TSLA as well. So we go here, we add another scanner. Select the scanner from our list of dropdowns. We can select another scanner that's already running.

Now we're not creating a clone of it or a copy of it. If we want to create a copy of it and modify it, we can start with this one and create a modified version. But here, we're just reselecting a scanner that we've already built, and because it has custom inputs, we then just changed the actual custom inputs. We change this to something a little bit more aggressive, maybe something like that and something like this, and then hit save.

There you go, you have a little symbol, a little portfolio that you're doing of monitoring positions. Now, in this case, you might want to make one little change. Let's just go back here, and again you wanna make changes to position limits and number of limits, etc., etc., but I'm showing you how to build these all out if you wanted to.

The next thing that we have to do now is we have to go and then build out our monitor automation. So all of this is really fun, and all of this is really cool. And hopefully, we get into a position because that's what we're hoping that these monitors do. And it's gonna continuously watch for an opportunity to get into a position. All of those are gonna be running at once, and let's say that one of them actually execute at some point.

We need to tell the bot exactly how we want the bot to manage any new positions. Now, remember, if we go into the actual automations, the only thing that we're doing here in this scanner is telling the bot what to look for to enter a new position. It's just entering a new position, in this case, a Long equity position.

So what we need to do now is we need to build out some monitor automations that tell the bot what to do if it has a Long equity position in its portfolio. So if a Long equity position is now opened, what do I do? And you're gonna tell the bot to do that here in the monitors.

So we click on the monitor plus icon, we’re gonna select from a list of automations. Notice that we don’t want to use this automation here. This is because this automation is a scanner. We don’t want to reuse a scanner here because we want to build out some new logic to tell the bot what to do when we get into a new Long equity position. So we’re gonna create a new automation.

We’re gonna name it something like “Trend + Momentum Monitor for Stocks.” Again, very specific, tells us exactly what this automation is doing and how we wanna use it inside of our bots.

First thing that we’re gonna do is we’re gonna add an action into our automation called the repeater. Now the repeater is really cool because what it’s gonna do is it’s going to allow the bot to cycle through and repeat through all the long equity positions that the bots ultimately ends up opening.

So if the bot opens a position in an APPL and TSLA, great, it will repeat through each of those positions. If the bot opens a position in APPL, TSLA, SPY, GLD, TLT, great, one automation can repeat through and manage each of those positions for you. You don’t have to tell the bot exactly to manage TSLA or exactly to manage TLT. You can tell the bot, “Look, any long equity position, manage it this way.”

So we’re gonna add a repeater. We’re gonna tell the bot what types of position to be on the lookout for. Because this particular bot that we’re building is for long equity, we’re gonna tell the bot to look for positions that the bot opens that are specifically long equity.

So anytime we have a new position that’s opened, it will start looking and checking to see if that position is a long equity position. And if it is, it now continues down the path of making regular decisions and closing or opening new positions as we go.

So here’s when we wanna actually, again, just take one step back and talk a little high level about how we would exit the position. In this case, because we’re going to be getting into positions when the stock is in an uptrend and when the stock has strong momentum, then when we get out of the position, we may want to exit the position if either of those two things turns out to go the opposite direction. Does that make sense?

So if the stock now is in the downtrend and is now trading below its 200 day moving average, that may be an exit point for us. Would you agree? Or if the ADX reading is now below some level that we set, that also might be an exit point for us.

So, in this case, for this bot, and again, create a different version of this. If you wanna add other things in here or create a modified version of this that you can share in the community. But for this example, we have two different exit points that we want to use when it comes to the technicals. So that’s the first that we’re gonna do. We’re gonna use technicals as our first two lines of defenses to when we would exit the position. So let’s build this out first, then we’re gonna build out another way to exit a position.

So in the first set of decisions that we’re gonna add, we’re gonna go here, and we’re gonna add some decisions. Again we’re gonna go to the same recipes that we use with the scanner; we’re just gonna build them in the opposite direction. So here we’re gonna go to a symbol is gonna be above or below, and we’re gonna change some of these variables.

Now again, you can type in the actual symbol here. You could say TSLA’s price is below whatever, but that doesn’t really help you because what if the position is in SPY or GLD? So instead, what you do is you link a custom input.

Now because this bot already have the info on the positions that you’re trading, you don’t have to create a new custom input that says symbol. You can just take the existing symbol from any existing position that the bot has.

You just tell the bot, “Hey, look, reference the symbol of the bot or of the position that you’re looking at and check to see if that symbol price is below the 200 day symbol moving average.” That’s our first decision.

So when the automation runs, let me just add it here, and we’ll go back and add some more. So when we first run the automation or when these monitor automations run, it’s gonna make sure it’s only looking at Long equity positions and for every single long equity position you have, every stock position you have; no matter if it’s TLT, GLD, APPL, GOOGLE, whatever. It’s gonna check and see if the symbol price is below the 200 day moving average. Okay? That’s the first decision.

Remember, that’s not the only thing we wanna check for. The other thing that we wanna check for is we wanna check and see if the ADX reading for that symbol is below some value. Again, we can link to the existing symbol of the position. And now we wanna check and see if the 14 day ADX is now trading below some low threshold.

Again you can type in the actual value here, or you can create an input. Since the bot doesn’t have- it’s not gonna reference what your value wants to be, we can just set a new custom input called ADX exit level. And our value right here might be something like 18. So if the ADX reading is now below 18, maybe the trend has changed, and we want to get out of the position. So we create a custom input for that.

Now we’ve added this to our list of decisions here. But is the actual logic the way that we want?

It’s gonna follow the yes path if the symbol price is below the 200 day moving average and the 14 day ADX reading is below our exit level. This means that in order for you to exit the position, the trend has to have changed, and momentum has to have changed. Of course, you can use it this way, but the way I described it earlier, we’re just gonna switch this right here in the middle to using an or statement.

So if either of these happen moving forward, if the trend changes or if the momentum changes, then build it out. So if either of these are true, then exit the position. So we save this. And now down the yes path, what are we gonna add here? We’re gonna add an action to close the position.

So if the symbol price is now below the 200 day moving average, or if the symbol’s ADX reading is now below our exit level that we set. We just simply want to close the position. What position? Well, the position for whatever the symbol is that we’re looking at at the time. This means that some symbols might be closed, and some symbols might not be closed based on their readings, right?

So if you’re trading TSLA and TSLA still on the strong uptrend with strong momentum, that won’t change. It won’t close the position. But if something else you’re trading has a trend change and it goes the opposite direction, then you can actually go in, and or the bot will go in and close just that one position, right? Just that one position.

Now two different ways that we can exit the position, all wrapped up into one automation. It’s also another way that we can exit the position. This, to me, is kind of covering our bases first, or we’re protecting our downside if the trend changes or if momentum changes, then exit the position. That’s great.

Now we wanna do something else. We wanna also give ourselves an opportunity to take profits. So if the position is profitable by some margin, we also wanna close the position, right? So that’s another way that we could look at exiting the position. You could also look at it from a bunch of other different thing; you could use a bunch of different technical indicators, maybe you use RSI as an exit, whatever you wanna do, you could use different variations. Just tell the bot exactly when you want to exit.


So now we’re gonna start building out some of the no path. So if we think about this, the automation starts; it’s monitoring our positions. It’s first gonna check and see if the trend or momentum changes. If that’s not the case and the answer is no, then I want to make new decisions.

I wanna make another decision to check and see if I have a profit. Now it doesn’t really matter in this case which one you use first. You could use the profit first; you could use the trend change first as a decision. It really doesn’t matter, but in our case, we’re gonna use this down the no paths, so you can visually see the difference.  

Now here we’re gonna go down. We’re gonna scroll down to our position recipes. And we’re gonna go here to position return being greater than some value that we set. So this is the position recipe where we can judge some variables around a position return.

So here we’re gonna select the position. Which position? Well, whatever position the bot’s looking at at the time. Then you go over to this field, and you can actually set some really cool things like you can set open PNL. So some may just ask in here, well, what if you wanna exit at certain dollar amount? Well, you can set that here, or you can set a certain return.

In our case, we’ll just use return for this example. So the position return is greater than 5.0, so 5% in our case. Again you can use this as a custom input. So you can manually set it as 5.0, meaning that when we save this, it will always be greater than 5%, or you can use a custom input value here so that you can swap these out later on for different bots that you run.

In our example, we’ll just keep this one as 5%, just to make it really easy, and we can visually see it.

So then we hit save, and now we save again to add this decision back to our decision tree. So when this automation runs, it’s gonna repeat through every long equity position, then it’s gonna check and see if the ADX price is below our exit level or if the symbol price below the 200 day moving average. And if it’s not, then it’s gonna check and see if it has a position return greater than 5%.

If that’s true and we basically met our profit target, then we’re gonna exit the position also. So, we can go here and close the position. And we just link out that same position that we’ve been using the whole time.

You could also go in here too if you want to get really creative with it. You can say, “Okay, is the something up the position-“ let’s see here. Is the symbols, and I’m just adding a bunch of these so you can see the different ways you can do it. Is the symbol’s 7 day RSI reading above 80? That could also be another way that you could close the position.

Notice you can just, at any point, use whatever recipes in here you want. You can use a combination of closing parameters for profits where the position return is greater than 5% and the symbol 7 day RSI is above 80. There’s truly a lot of ways that you can do this.

I’m gonna delete these two real quick, just so we keep it really simple. Now we have our monitor automation completely 100% built out. Very easy to use. Super super flexible and ready to go.

All the automations are saved, saves automatically as you go. You just simple exit out of here, reconfirm that exit level that we had put in before, and now we go ahead and save. And now we have our monitor automation in place.

What’s really cool about this. I’ll turn on the automations, and we get these things working. And actually, I’m just gonna keep one of these in place here. Let’s just keep, let’s keep APPL in place. So we’re gonna delete this one, and then we’re gonna delete this one. We’re just gonna keep one in place here.

We’re gonna let this run through the next cycle here at 4:45. As we’re talking through this, now as we’re going through this, we can, you know, see how it works. But right now, it has no positions.

We’re gonna let it run through the next opportunities set at 4:45. Check back in here; the log should show that the scanner automation is gonna run. We’re gonna see what the results are, and if we enter new position, then it’s gonna start monitoring the next position tomorrow, right? The next run.

So we have our monitor automation. Our monitor automation is in place, watching, waiting for positions. If the bot opens any positions that are long stock, it will send it through the sequence every 50 minutes, looking for a way to exit the position. And if the answer to these questions is continuously no, then it will- excuse me, continue holding positions going forward.

That’s it. That’s how you build out this Trend + Momentum bot. First thing I’m gonna do is I’m gonna go in here, by the way, and I’m going to save this. This is how you guys get a copy this template. So watch and pay attention as we go.

First, I’m gonna save this bot as a template. There’s a brand-new template; I’m not updating an existing one. And this is trend- whatever description you want. Trend + Momentum from Bot Workshop. And I’m gonna create a new template for myself.

So inside of this new template, I can add on my personal notes. I can make edits and revisions. I can spin up and whip up bots in this, or I can go right here, and I can share this with the community.

I’m gonna wrap it up there. Thank you, everyone, so much for joining. Have a great day, everyone. Thank you guys so much; if you haven’t had a chance to check out the live QnA from the other day, please check out the live QnA from the other day. We answered a lot of questions around timelines, and where we’re at, and what we’re working on next.

Also gave you some sneak peeks of some really cool things like formulas. I think you guys will really enjoy it. So take a look at that. Check your email. We sent out that link this morning. If you don’t have that, send us an email [email protected] We’ll make sure we get a copy of it to you.

All right, have a great rest of your day. Until next time, happy trading.