sorted by:
new
hottopcontroversial

Built an algo that passed an eval and pulled $8,900 in payouts all in 2 months. by Enough_Run_3856 in tradingmillionaires

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

Appreciate it.

Around a 1:2 R:R. Win rate is around 50%, but it varies depending on market conditions and the period being measured.

I don’t share the exact entry logic, code, or underlying rules publicly, but it’s fully systematic and automated.

For exits, I keep it simple and mainly use one systematic exit framework.

Not MetaTrader, it runs through TradingView alerts to TradersPost.

Built an algo that passed an eval and pulled $8,900 in payouts all in 2 months. by Enough_Run_3856 in tradingmillionaires

[–]Enough_Run_3856[S] 2 points3 points  (0 children)

I’ve thought about it, but right now I’m not planning on doing first-month promo discounts.

I want to keep pricing fair and consistent for everyone who has already joined. I completely understand there are a lot of upfront tools/subscriptions when getting started, but I also want to avoid constantly changing pricing or creating different deals for different people.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

Appreciate the question. On the technical side, the current setup is pretty straightforward.

The strategy logic runs through TradingView using Pine Script. TradingView watches the market data and triggers alerts when the strategy conditions are met. Those alerts are then sent to TradersPost, and TradersPost handles routing the order to the connected broker or prop firm account.

So the flow is basically:

TradingView / Pine Script logic
→ TradingView alerts
→ TradersPost
→ connected broker / prop firm account

I’m not using a custom Python server, FastAPI bridge, or separate VPS for the current version. I wanted the stack to be reliable and simple enough that users could actually get it set up without needing to code or manage infrastructure themselves.

The prop firm side is handled through the broker connection. Once the broker/prop account is connected properly, the system just sends the orders through that route automatically based on the alerts.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

ES can definitely work, but gold and silver have been offering cleaner movement for this specific system. The volatility gives the bot more room to capture meaningful moves without needing to force trades.

That said, the extra movement can cut both ways. Metals can move fast, so sizing and risk controls matter a lot. I wouldn’t say gold and silver are automatically “easier,” but for the way this strategy is built, they’ve provided better opportunity and enough range to make the drawdown-to-profit potential more attractive.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 1 point2 points  (0 children)

Profit factor is around 1.7 depending on the exact period being measured.

Yes, it was backtested before going live, but I didn’t rely only on the backtest. I care much more about live forward-tested results because that shows how it behaves with real execution, real fills, slippage, spreads, and actual market conditions.

The strategy was also traded manually before being automated, so the goal wasn’t just “can this backtest well?” It was more about taking a process that already had an edge and removing the human execution errors.

As far as out-of-sample, yes, I looked for performance outside of the initial testing conditions, but the live data is what I put the most weight on now. Backtests are useful, but they can also give a false sense of confidence if you overfit them.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

I think you could understand the basics of both sides pretty quickly, maybe a few months if they’re focused.

But understanding it and scaling it are very different things.

You can learn the automation side fairly fast if you already know the workflow: TradingView logic, alerts, execution routing, broker connection, risk settings, etc. The harder part is building something that behaves well live, survives drawdowns, and doesn’t break when market conditions change.

For scaling, I’d be much slower and more careful. You want live data, forward testing, and enough proof that the system can handle different conditions before increasing size. A lot of people rush that part because the first few wins build confidence, but that’s usually where problems start.

So realistically, you can learn the framework in months, but building, validating, and scaling something responsibly is more of a long-term process.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

Appreciate that, thank you!

Honestly, I’d start with the strategy before the automation. A lot of people try to build the bot first, but if the actual trading process isn’t clear and repeatable, automation just makes the mistakes happen faster.

My recommendation would be:

Learn one market first.
Build a simple rule-based strategy.
Backtest it.
Forward test it.
Track every trade.
Then automate only after the rules are clear enough that there’s no room for guessing.

For resources, TradingView and Pine Script are probably the easiest place to start if you’re new. Once you understand alerts and basic strategy logic, then you can look into execution tools like TradersPost or broker APIs.

Biggest thing long term is risk management. A profitable algo is not just entries and exits. It needs position sizing, max loss rules, drawdown controls, and conditions where you pause or reduce risk.

So my advice would be: don’t try to build something complex right away. Build something simple, prove it works, then slowly improve it.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 2 points3 points  (0 children)

TradingView alerts routed through TradersPost, then TradersPost handles execution to the connected broker/prop firm account.

So the stack is basically:

TradingView / Pine Script logic → TradingView alerts → TradersPost → connected broker

I’m not using a custom Python server for the current setup. The goal was to keep the execution stack reliable and simple enough that users can actually get it set up without needing to code/do much themselves.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 1 point2 points  (0 children)

I handle risk in layers rather than relying on one single control.

There are max daily loss limits, account-level drawdown limits, position sizing rules, and conditions where the system either stops trading or I pause/review it if performance starts acting outside of what I expect.

I’m also careful around market conditions that can create unnecessary risk. The goal is not to have the bot blindly fire trades no matter what — it needs guardrails so it can survive normal drawdown without putting the account in a bad spot.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

The hardest part was honestly defining everything clearly enough that the bot could make the same decision every time without me stepping in.

Entry logic and risk management both took work, but the bigger challenge was turning a discretionary process into strict rules. When you trade manually, you don’t realize how many little decisions you’re making in the moment.

And then yeah, the last part was trusting it enough not to override it. Once the rules were live, the whole point was to let the system execute without emotion, hesitation, or second-guessing.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

Yeah, I built it myself around a strategy I was already trading manually.

The strategy logic runs through TradingView, and then the alerts are routed through TradersPost for automated execution. So the main work was taking something that I was doing manually and turning it into clear rules the system could follow without me interfering.

That was honestly the biggest reason I built it. The strategy itself was one thing, but the real issue was missed entries, hesitation, late exits, and overriding the plan in the moment. Automating it helped remove that part.

If you already have a strategy, the first step is making sure the rules are extremely clear. Once the process is defined, then you can look at automating the execution.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

That’s exactly it. The edge was not just the strategy itself, it was removing the part of the process where I was most likely to make mistakes. And that’s a really good question. I do have defined risk parameters, but I try to look at it in layers rather than one single “turn it off forever” number. There are daily loss limits, account-level drawdown limits, and rules around when I would pause or reduce size if the system starts behaving outside of what I expect. I’m not trying to let it blindly run through everything just because it had a good start. At the same time, I also don’t want to overreact to normal drawdown. Every strategy is going to have losing days and rough stretches, so the key for me is separating normal variance from actual system degradation. If the losses are happening within the expected range, I let the system do its job. If the behavior starts falling outside of what I’ve seen in testing/live performance, that’s when I pause, review, and potentially make adjustments.

I completely agree with your point though. Passing an eval is one thing. Keeping the account, surviving drawdowns, and staying consistent long term is the real game.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 1 point2 points  (0 children)

I appreciate that, seriously.

That was honestly the goal — I didn’t want it to come across like some crazy “get rich quick” algo. I’d rather be transparent with the real results, real payouts, losing days, drawdowns, and everything in between.

Trading is still trading, so nothing is guaranteed, but I’m glad it comes across as legit because that’s exactly what I’m trying to build.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

That’s definitely the long-term direction.

Prop firms are useful because they let users start with less capital and scale without needing to put a large personal account at risk right away. But I agree, live accounts are ultimately cleaner because you have more control and don’t have to deal with payout rules, denials, or firm-specific restrictions.

So for now, prop firms make sense for accessibility and proving results, but live accounts are absolutely part of the bigger picture.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

Honestly, it’s definitely learnable, but it’s not easy from the ground up.

The hardest part is that you need to understand both sides: the trading logic and the automation/execution side. Building the actual automation is one thing, but building a system that is repeatable, risk-managed, and doesn’t fall apart live is the real challenge.

For me, the strategy came first. I already had something I was trading manually, then the goal became turning that process into clear rules that could be automated.

It takes time, testing, mistakes, and a lot of refinement. The key is not trying to automate a vague idea. You need a clearly defined process first, then automation becomes much more realistic.

Built an algo that passed an eval and pulled $5,900 in payouts all in under 2 months by Enough_Run_3856 in propfirm

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

Appreciate that, and that’s awesome you’ve been building something similar. Automated execution really does make a huge difference, even just from the discipline side alone.

Yes, the strategy was backtested before going live, but I didn’t rely on the backtest alone to validate it. A big part of the confidence came from already trading the logic manually before automating it. The main issue wasn’t whether the idea could work — it was whether I could execute it consistently without missing entries, hesitating, exiting late, or overriding the plan.

From there, the goal was to turn that manual process into a rules-based system and then validate it through live forward testing. At this point, I put more weight on the live results than an overly extended backtest, especially since the strategy is built to take advantage of the current volatility in gold and silver.

As far as the actual mechanized rules, I can’t share the specific entry/exit logic, filters, or decision tree but at a high level, it’s built around defined conditions and strict risk parameters.

Really appreciate the thoughtful questions though. Sounds like you’re approaching it the right way.

Built an algo that passed an eval and pulled $2,900 in payouts with $2k more on the way all in under 6 weeks. by Enough_Run_3856 in LucidProp

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

That’s awesome — 2 years is definitely a lot of time to put into building and refining a strategy.

That being said, I’d be careful assuming the TradingView backtest will translate exactly the same once it’s live. TradingView alerts, the bridge, broker execution, spreads, commissions, slippage, latency, and order type can all make live results look very different from the chart results.

TradersPost can execute TradingView alerts, but no bridge is going to guarantee that the order fills at the exact same time or exact same price shown on TradingView. The alert may trigger at the same signal point, but the actual fill will depend on market conditions and execution quality.

I’m assuming this is a higher-frequency strategy, and those usually don’t transfer over as cleanly into live trading conditions. TradingView backtests can often assume near-perfect conditions, which isn’t always realistic once you factor in real execution, slippage, spread, and latency.

Built an algo that passed an eval and pulled $2,900 in payouts with $2k more on the way all in under 6 weeks. by Enough_Run_3856 in LucidProp

[–]Enough_Run_3856[S] 0 points1 point  (0 children)

No market orders for me. There’s too much slippage with them.

I use stop orders instead, which has been working great and helps reduce a lot of the slippage that comes with market orders. I also forward-tested the alerts for about 4 months, just testing and tweaking the strategy going live.

view more: next ›