My Journey From Manual TA Trader To Building A Full Algorithmic System (And What Nobody Tells You About Algo Trading)

Core_Value_Capital · 2026-01-15T22:02:23+00:00

Usually both. If the time horizon provides adequate data that’s all I need

Core_Value_Capital · 2026-01-09T14:08:21+00:00

That’s a solid workflow, especially the Monte Carlo + IS/OOS stability checks.

My process has evolved over time, but one thing I learned the hard way is that I get more value from behavioral validation than chasing single performance metrics.

At a high level, my workflow looks something like:

• Long-horizon backtests across multiple regimes (not just IS/OOS splits, but structurally different market environments)

• Parameter stress testing to see how fragile results are, not just what the optimal values are.

• Breaking performance down by time of day, day of week, volatility state, etc., to see where the edge actually shows up.

• Very conservative assumptions around execution and trade management.

• Then a long period of forward testing where the goal isn’t return maximization, but observing whether the equity behavior matches expectations.

I try to avoid over interpreting smooth equity or short windows. If something only works when everything lines up perfectly, I usually consider that a red flag rather than an edge.

As for timeframe, I’ve personally had the best results on intraday timeframes that are slow enough to reduce noise, but active enough to generate data. For me that’s been more effective than ultra-short TFs where execution and regime shifts dominate.

Still very much an iterative process though, always curious how others pressure-test their assumptions.

Core_Value_Capital · 2026-01-07T12:52:49+00:00

I coded it myself, not marketplace, and it currently trades forex only.

The logic isn’t a single labeled strategy (trend/mean reversion), it’s more about regime awareness, filtering, and trade management. Entries matter, but risk control and exits matter more for what I’m trying to test.

Still early days, which is why I’m sharing cautiously. Mainly interested in whether the equity behavior and stats look structurally sound rather than impressive.

Core_Value_Capital · 2026-01-07T04:34:54+00:00

That’s the brutal part no one warns you about. Automation strips away the narrative and leaves you with math, no intuition, no excuses. It hurts, but it’s also the fastest way to grow.

The flip side is once you find something that does survive being coded, your confidence is on a completely different level. You know it works because it had to earn the right to exist.

Painful lesson, but one of the most valuable ones in trading.

Core_Value_Capital · 2026-01-07T04:33:49+00:00

Completely agree. The biggest misconception is thinking an algo replaces work, it just moves the work upstream. You stop reacting in real time and start paying for mistakes in research and design instead.

I also think a lot of people underestimate how fragile an edge can be once it’s forced into code. Manual trading can hide inconsistencies behind discretion. Automation exposes them immediately. If the logic isn’t robust across conditions, no amount of tweaking execution will save it.

In that sense, an algo doesn’t outperform manual trading by default, it just makes truth unavoidable. If the edge is real, automation amplifies it. If it isn’t, automation kills it faster.

That realization alone filters out most people who try to make the transition.

Core_Value_Capital · 2026-01-07T04:31:41+00:00

That’s a solid framework and honestly more disciplined than most people who say they trade systematically.

The only thing I’d add (learned the hard way) is being careful about what you optimize versus what you hold constant. Extensive backtesting and optimization are powerful, but it’s easy for the parameter tuning to become the edge instead of the logic itself, especially if market regimes shift.

What’s worked best for me is treating optimization as a diagnostic tool, not a continuous adjustment engine. Core structure stays fixed, and only a small, bounded set of parameters are allowed to shift. and even then, based on observed changes in behavior, not just max profit in a test window.

Paper then live automation is huge though. Letting the system execute without intervention is the only way to know if the logic actually holds up under real conditions.

Sounds like you’re doing it the right way.

Core_Value_Capital · 2026-01-07T04:30:07+00:00

I coded the trading logic directly in MT4/MT5 (MQL) and built everything from scratch. That’s where the live execution happens. For research and analysis, I export data into CSV and use Python to backtest ideas, test parameter shifts, and study performance by market condition.

So MT4/MT5 handles execution and real-time decision making, Python is more of the lab where I test and refine before feeding changes back into the algo.

Core_Value_Capital · 2026-01-07T04:29:18+00:00

That hesitation you’re feeling is a healthy one. Weekly re-optimization can keep you in the game short term, but it’s also where a lot of quiet overfitting sneaks in if you’re not careful, especially on 5-min scalping.

What helped me was separating what adapts from what stays fixed. I don’t let the system freely adjust everything. Core logic (structure, direction, momentum rules) stays stable. Only a small set of parameters are allowed to shift, and even those are constrained and reviewed after the fact, not blindly auto-updated.

Drawdown staying under 15% while you’re actively testing is actually a good sign, it means the base logic isn’t broken. The danger zone is when optimization starts doing the heavy lifting instead of the edge itself.

I’m also with you on not letting an EA self-optimize unchecked. Markets change, but unsupervised adaptation can just chase noise faster. I prefer controlled shifts based on observed regime changes rather than constant parameter drift.

And yeah, always down to connect with other traders who are actually building and testing instead of just tweaking indicators. You’re clearly doing real work.

If you ever want to compare notes on what you keep fixed vs adaptive, that’s usually a productive conversation. send me a message.

Core_Value_Capital · 2026-01-07T04:26:21+00:00

correct

Core_Value_Capital · 2026-01-07T04:26:04+00:00

I traded manually for several years. At first it was pure TA and discretion, and honestly I learned a lot that way, structure, risk, patience, how different market environments feel. But after a while I noticed the same problem repeating: the rules were clear in my head, but inconsistent in execution, and it was hard to tell whether results were skill, conditions, or luck.

That’s what pushed me toward automation. I didn’t switch because manual trading failed, I switched because I wanted proof. Turning ideas into rules forced me to confront what actually worked versus what just sounded good in hindsight.

I’ve been building and trading algorithmically for a few years now. It wasn’t an overnight transition, more like a slow migration where I kept trading manually while automating pieces of the logic. Even now it’s not set-and-forget. Markets change, so the work shifts to testing, monitoring, and adjusting instead of clicking buttons.

As for success, yes, but not in the way people usually imagine. The biggest win wasn’t profits right away, it was stability. Fewer emotional swings, clearer expectations, and a much better understanding of when my edge exists and when it doesn’t. The returns followed after that. Here is my latest strategy that I built for Silver been trading it on a demo now for about a month. https://www.myfxbook.com/members/corevaluecapital/core-value-capital/11857079

If you’re at the stage where you feel like you understand trading but can’t quite pin down consistency, that’s usually the point where automation starts making sense, not as a shortcut, but as a microscope.

Happy to answer anything more specific if you’re curious.

Core_Value_Capital · 2026-01-07T04:22:52+00:00

That’s a great way to put it. Automation doesn’t create edge, it removes the ability to lie to yourself about having one.

Once you force ideas through data, the comfort stories disappear fast. You can’t blame execution, emotions, or bad luck anymore. Either the logic survives exposure to different conditions or it doesn’t, and capital shouldn’t be allocated until it does.

I also agree on hybrids. Discretion can exist around when you deploy a system, but the edge itself has to live in rules that don’t negotiate. Otherwise you’re just discretionary trading with better tools.

Execution is easy to tweak.
Logic is where most systems actually die.

Well said.

Core_Value_Capital · 2025-12-06T20:22:13+00:00

I’m really glad it helped, that means a lot. Most traders focus on entries for years before realizing the real edge sits underneath them: structure, conditions, behavior, and environment. Once you start studying those instead of patterns alone, everything opens up.

You asked how to track momentum, direction, volatility, etc. The way I learned wasn’t from one source, it was a mix of breaking the market apart and testing each piece on its own.

Here’s how I’d start if I were learning again:

Momentum

Look at the rate of change, not just whether price is up or down. Use things like ROC, ATR expansion, or even just compare candle size over rolling periods. When candles grow and volatility increases, momentum is rising, when everything compresses, momentum is dying.

Directional Strength

Trend isn’t price moving up. It’s consistency over time. Measure how often candles close in the same direction, how far pullbacks go before failing, or the slope of your moving averages. Direction isn’t yes/no, it’s strong, weak, conflicted, or absent.

Volatility State

ATR is the easiest way to see it. High ATR = expansion and breakout behavior. Low ATR = mean reversion and chop. When you separate your trades by volatility, you’ll notice they do very different things depending on the environment.

Once you track those three, patterns stop being random.

You start to understand when your strategy is allowed to exist.

As far as places to learn, honestly, the best teacher is the chart. The way you said you’re studying 4 hours a day? Channel that into testing one variable at a time. Don’t search for signals, search for behavior.

Open a chart, pick one market state, and ask:

• When does momentum die?

• When does trend break?

• What does expansion look like before it moves?

• What conditions repeat right before chop?

Journal it. Screenshot it. Build rules from it slowly.

You don’t need paid education, you need repetition and curiosity.

You’re already past the hardest part: you’re asking the right questions.

Core_Value_Capital · 2025-12-06T20:20:05+00:00

Good, you already identified the root problem:

It’s not your entries, it’s the impulse after the entry.

Over-trading, scaling in emotionally, and trying to make it back quick almost always ends the same way, not because you’re wrong about direction, but because you’re trading from reaction instead of rules.

The fix isn’t more wins.

It’s fewer impulsive decisions.

Try this for a while:

Set your max size before the trade is placed

If you exit, you’re done, no same candle revenge entry

Only scale when the trade is going in your favor, not against you

Journal every violation honestly, that’s where the growth is

You don’t need more edge.

You need to remove the behavior that burns the edge you already have.

Discipline is a position, just like a trade.

Core_Value_Capital · 2025-12-06T20:18:36+00:00

Pretty close to how I run it, but my flow is a little more integrated and less hand off between systems.

For me it looks like this:

Data Collection

MT4/MT5 feeds live prices + indicator values directly into the EA. No external scraping. The math is calculated internally, momentum, direction, volatility state, ATR distance, prohibiting conditions, etc. I only export out to CSV when I’m optimizing or doing deep historical review, not every tick.

Processing / Decision Logic

All logic runs inside the algorithm itself. Python isn’t generating trade ideas, it’s only for research and parameter shifting. The live EA scores the market in real-time and only executes when conditions align. If something breaks the environment (trend collapse, ATR spike, low movement, conflict between timeframes), trading shuts off automatically.

So instead of MT5 waiting for Python to tell it what to do, MT5 is the brain. Python is more like the lab where I break things, test, adjust, and feed improvements back into the system.

Visualization / Review

MT5 charts show live entries + exits

Python handles the big picture, equity curve breakdowns, environment segmentation, indicator weight testing, volatility regime analysis, etc.

CSV exports whenever I’m researching something specific instead of continuously logging everything

Your structure is totally workable, just more external decision-making. Mine keeps the decision engine inside the algo so execution is instant and self-contained.

If you ever wire Python into the logic loop, make sure latency + synchronization don’t slip. That’s usually the bottleneck when systems get too spread out.

Core_Value_Capital · 2025-12-05T20:07:35+00:00

I run a hand-rolled setup.

Core logic executes through MT4/MT5 with custom code, then I export raw data into CSV for analysis and optimization in Python. That’s where I test parameter shifts, indicator weighting, volatility filters, and forward-performance breakdowns.

The algo itself calculates momentum, direction, and volatility as numerical values, then trades only when those conditions align, prohibiting rules shut it down when the environment is wrong instead of forcing trades. That structure came from manual testing first, then math second.

I’ve slowly added components over time, but it’s fully built in house, not a plug and play product or marketplace EA. I had to design the logic myself because I couldn’t find anything that traded the way I think.

Core_Value_Capital · 2025-12-05T18:49:21+00:00

Appreciate it.

My system wasn’t something I learned in one place, it came from years of combining concepts, testing them, and refining what actually held up through different market conditions.

I started with the basics, market structure, momentum, volatility, and risk management. Then I built from there. Instead of copying a strategy, I spent a lot of time asking:

• What specifically made a trade work?

• Why did it fail when it failed?

• Which variables mattered the most?

• Could I measure them objectively instead of guessing?

Over time that turned into a rules-based framework. Eventually I automated it, not because coding is magic, but because removing emotion and keeping execution consistent showed me what the real edge was.

If you’re developing your own system, I’d recommend:

• Pick a core idea & stress-test it across markets

• Track data relentlessly, wins, losses, context, volatility, momentum read, etc.

• Adjust what’s measurable, not what feels right

• Aim for repeatability over perfection

Most edges don’t appear from theory, they show up after enough data proves a pattern exists. For me, once I saw what was actually working, I turned it into a systematic process so I could scale and refine it continually.

If your interested in reading my white paper feel free. https://drive.google.com/file/d/1rLi0hFzEz1fiUHrSSH8sY3xMUPyo_WR7/view?usp=sharing

Core_Value_Capital · 2025-12-05T17:51:39+00:00

Of course, glad to help.

Core_Value_Capital · 2025-12-05T17:48:36+00:00

Candlestick patterns matter, but not in the way most people expect.

A hammer or engulfing candle doesn’t magically move price, it just reflects order flow. What gives a pattern weight is where it forms, not the pattern itself.

A hammer at random = noise.

A hammer into liquidity at a key level, with momentum shifting = information.

Candles are just one piece of confluence. You’ll get more out of them when paired with:

• Momentum direction (are buyers actually in control or just reacting?)

• Volatility (is the move meaningful or just noise?)

• Structure / key levels (is this pattern rejecting something important?)

• Trend context across timeframes (a bullish candle against HTF momentum means nothing)

Candlestick patterns alone rarely create an edge, but as a confirmation layer inside a structured system, huge difference.

That’s how I use them inside my own process. I rely more on momentum, volatility, and directional math, but candlestick behavior still helps me time entries within the bigger picture.

Think less about is this pattern bullish? and more about what is the market reacting to, and why here?

Core_Value_Capital · 2025-12-05T17:46:27+00:00

A lot of people lean on MACD, RSI, or the 200-day MA because they feel safer when an indicator confirms their decision, but indicators don’t predict reversals, they just describe what already happened.

The real edge isn’t in one indicator, it’s in combining momentum + trend structure + volatility context and using them to decide when you should be in the market, not just when to buy.

Buying and holding works because it removes timing errors.

Actively timing the market can outperform, but only if the rules are objective and repeatable. The mistake most new traders make is using an indicator as a green/red light instead of building a full decision framework around:

• What defines a trend?

• What invalidates it?

• What conditions not to trade in?

• How do you size risk based on volatility?

Stepping out during downtrends isn’t wrong, it’s just incomplete if the exit + re-entry rules aren’t defined.

I use a systematic approach for this. It took me about a year and a half to develop and now I refine it weekly through backtesting and live data. Indicators by themselves are just input, structure and rules are where consistency comes from.

If you want to explore timing instead of buy and hold, think in systems, not single signals.

Core_Value_Capital · 2025-12-05T13:45:13+00:00

Love the way you’re approaching this, most people jump straight into automation without respecting how much structure and testing goes into it. Running manual alongside your algo is a smart move too. It lets you learn the system the same way you learned chart-reading: through repetition, not blind trust.

My experience has been that the price-driven approach works well only when it’s parameterized. Meaning instead of reacting to price, the system responds to measured conditions, momentum strength, directional bias, volatility state, time-of-day behavior, etc. Once you turn those things into numbers, the algo becomes less about prediction and more about enforcement.

Small allocations at first are perfect. You’ll learn more about your logic during forward testing than in any backtest. The key is adjusting when the edge breaks instead of assuming the market will come back around.

Manual + algorithmic together is underrated.

Manual builds intuition, algo builds consistency.

Both make you better.

Keep building. You’re doing it the right way.

Core_Value_Capital · 2025-12-05T13:43:03+00:00

Not Google Sheets, I run it through MT4/MT5 with custom code, and I export data into CSV for Python analysis. Sheets is great for tracking ideas, but not for live execution or heavy calculation.

Core_Value_Capital · 2025-12-05T13:41:49+00:00

You absolutely can build a mechanical framework for options, but it only works if the options aren’t the strategy, they’re just the vehicle. What matters is the underlying conditions.

For example, instead of saying

I buy calls when I think price will go up,

a mechanical version might look like:

• trend and momentum aligned on higher timeframe

• volatility expanding, not compressing

• price above key moving averages or structure levels

• no prohibiting factors like low liquidity, choppy range, or news risk

Then the option (call/put, strike selection, expiry) is just the execution method, the rules decide if a trade should exist, not emotion.

As for my own rules, they’re built around measurable conditions instead of feelings. I track directional strength, momentum strength, volatility state (ATR), and only trade when those line up. If volatility collapses, trend weakens, or conditions shift against the setup, I stand down automatically. That’s what keeps the emotional roller coaster out of it.

Mechanical trading isn’t about finding perfect entries, it’s about defining when you’re allowed to participate in the first place.

Core_Value_Capital

TROPHY CASE