Goldmine Trading Bot

I've been building a trading automation product for Gold (XAUUSD), and one of the biggest lessons I've learned has nothing to do with writing code.

The hardest part isn't deciding what your trading bot should do.

It's deciding what it should not do.

When you start building an automated trading system, it's tempting to keep adding features.

More indicators.

More entry conditions.

More markets.

More timeframes.

More filters.

More "smart" logic.

More settings.

Eventually, you can end up with a complicated system that looks impressive on paper but is difficult to understand, test and maintain.

That was one of the things that made me rethink how I wanted to build Goldmine.

Start with one problem

Goldmine is focused on one market:

Gold (XAUUSD).

And one primary environment:

MetaTrader 5.

That constraint is intentional.

Instead of trying to build an EA that trades every forex pair, cryptocurrency and index, we're starting with a market that we understand deeply and building around a specific use case.

I think there's an interesting product lesson here.

Sometimes the best way to make a product more useful is to make its scope smaller.

Automation creates a different kind of problem

With a manual trading strategy, a trader can look at a chart and make contextual decisions.

A human can say:

"This setup technically qualifies, but something doesn't look right."

A computer doesn't have that intuition unless you explicitly program the conditions that represent it.

So when converting a trading strategy into software, you have to turn vague ideas into rules.

Instead of:

"The market looks bullish."

You need something closer to:

"If conditions A, B and C occur, the system considers a long setup."

That's where the real work begins.

You have to define:

• What qualifies as an entry?

• What invalidates the setup?

• When should the system stay out?

• How should risk be calculated?

• When should a position be closed?

• What happens during unusual volatility?

• What happens if market conditions change?

• What happens when the strategy loses?

Those questions are much more important than adding another indicator.

Backtesting can also create false confidence

Another lesson I've learned is that a beautiful backtest isn't necessarily a beautiful product.

It's very easy to optimize a strategy against historical data until the results look fantastic.

But that's not the same thing as proving that the strategy will perform the same way in the future.

That's why I'm increasingly interested in the process around testing rather than simply the final number.

A serious automated trading product needs to consider things like:

Out-of-sample testing

Forward testing

Different market conditions

Drawdown

Transaction costs

Spread

Slippage

Execution conditions

And, most importantly, the possibility that the strategy simply doesn't work as expected.

That last part is uncomfortable, but I think it's necessary if you're building a financial product.

Don't hide the risk

Trading software is a strange category.

You can build an excellent product and still have users lose money because markets are unpredictable.

That means the product experience can't be based entirely around showing the best possible results.

I don't want Goldmine positioned as a machine that guarantees profits.

There are no guarantees in trading.

Instead, I want users to understand what the system does, what assumptions it makes, how it can be configured and what risks are involved.

I think transparency is going to become increasingly important as more automated trading products enter the market.

The product is bigger than the bot

Goldmine started as an Expert Advisor.

But I'm beginning to think about it as a broader product ecosystem.

The future could include:

• automated trading tools

• indicators

• strategy development

• analytics

• educational resources

• research tools

• other systematic trading products

But I'm deliberately trying not to build everything at once.

The first job is to make the core product useful.

Then listen to users.

Then improve it.

Then expand.

The founder lesson

Building Goldmine has reinforced something I've seen repeatedly in product development:

A smaller product with a clear purpose can be more valuable than a bigger product with a confusing purpose.

Every feature has a cost.

Every additional market adds complexity.

Every additional setting creates another decision for the user.

Every new piece of logic creates something else that needs to be tested.

So I'm learning to ask a different question whenever I want to add something:

Does this make the product meaningfully better for the person using it?

If the answer is no, it probably doesn't belong in the product.

That's the principle I'm taking forward as we continue building Goldmine.

I'd love to hear from other Indie Hackers:

Have you ever removed features from your product and found that the product actually became better?

What made you decide what to leave out?

Hey everyone,

I'm Stephen, founder of FXM Brand, and I'm building Goldmine, an automated trading product for MetaTrader 5 focused specifically on Gold (XAUUSD).

I wanted to share the story behind it because I'm interested in hearing from other founders, traders and builders who have experience turning a niche problem into a real product.

Why Gold?

I've spent a lot of time studying and trading Gold, and one thing became increasingly obvious to me: XAUUSD is a very different market from simply throwing an automated strategy at multiple forex pairs.

Gold can move aggressively, liquidity conditions can change quickly, and discretionary traders have to deal with the same problems over and over:

• emotional decisions

• inconsistent execution

• missed setups

• overtrading

• constantly monitoring charts

• abandoning a strategy after a few losing trades

That led me to a simple question:

What if we focused on building an automation product specifically around the way Gold traders actually trade?

That became the starting point for Goldmine.

What we're building

Goldmine is an MT5 Expert Advisor designed to automate a predefined trading process for XAUUSD.

The goal isn't to create a magic box that guarantees profits. Trading doesn't work that way.

The goal is to take a defined trading methodology and turn it into a more systematic execution process.

The trader still needs to understand the risks, choose appropriate settings and manage their account responsibly.

Why build an EA instead of another indicator?

This is something I've thought about a lot.

Indicators can help traders identify conditions, but there is still a large gap between:

seeing a setup → deciding what to do → executing → managing the trade → closing the position.

Automation gives us the ability to turn a defined process into something repeatable.

That doesn't make the underlying strategy perfect.

It simply removes some of the inconsistency that comes from manually executing the same rules hundreds of times.

The difficult part isn't writing the bot

One of the biggest things I've learned is that building the software is only part of the problem.

The harder questions are:

What should the product actually do?

How do you test it honestly?

How do you communicate performance without making unrealistic promises?

How much control should the trader have?

How do you build trust in a financial product?

Those questions have influenced how we're developing Goldmine.

We're trying to avoid the typical "make money while you sleep" approach that surrounds a lot of trading software.

Instead, we want users to understand what they're buying, how it works, what the risks are and what the limitations are.

Where we're going

Goldmine is currently centered around XAUUSD and MetaTrader 5, but I don't see the product as just one Expert Advisor.

The longer-term vision is to build a broader trading-technology ecosystem around:

• automated trading

• trading indicators

• strategy development

• analytics

• education

• systematic trading tools

The EA is the starting point.

We're also preparing for Product Hunt

We're currently preparing Goldmine for a Product Hunt launch.

That has forced me to think about the product differently.

Instead of only asking:

"Does the strategy work?"

I'm now asking:

"Would someone who doesn't know me understand this product?"

"Can they see what they're getting?"

"Can they evaluate the risks?"

"Does the product actually solve a problem worth paying for?"

That's been a valuable exercise.

I'd love feedback from other builders

If you've built a SaaS product, trading tool, fintech product or anything in a niche market, I'd love to hear your experience.

Especially:

1. How did you build trust when your product operates in a high-risk category?

2. What convinced your first customers to try your product?

3. How much product transparency is enough?

4. Would you rather buy a specialized product that does one thing well or a platform with dozens of features?

5. For trading software specifically, what information would you want to see before giving it access to a live trading account?

I'm building Goldmine as a real product, not just a trading experiment, so I'm interested in the lessons other founders have learned.

If you'd like to see what we're building, the current product page is here:

We have a coupon code for IndieHackers willing with experience the magic of the bot at $70 only instead of the normal $250 which it has been sold in forex market and forums.

CODE ::: 70PHOFFER

https://selar.com/b71a157jym

And I'm happy to answer questions about the product, the development process or the business.

Thanks for reading.

I didn't originally set out to build a trading brand.

I was trying to solve a trading problem for myself.

That eventually became what I now call the Goldmine Strategy — a trading framework focused primarily on Gold (XAUUSD), particularly the way price behaves around specific market sessions, liquidity and structured price-action setups.

What has surprised me isn't just how the strategy evolved.

It's what happened after I started publishing the idea online.

It started with a question about Gold

Gold has always fascinated me because of how aggressively it can move.

One minute the market looks completely dead.

Then liquidity gets taken, volatility expands and XAUUSD can make a significant move in a relatively short period.

I spent a lot of time studying those movements.

Instead of asking:

"How can I predict where Gold will go?"

I started asking:

"Are there recurring conditions that appear before some of Gold's larger moves?"

That changed the way I looked at the market.

I began paying much more attention to:

• Session timing

• Consolidation

• Liquidity

• Breakouts

• False breakouts

• Price-action confirmation

• Market structure

• Risk management

The idea wasn't to find a magical indicator.

It was to find a repeatable process.

The Asian session became particularly interesting

One of the things that stood out to me was the behavior of Gold during quieter market periods.

The Asian session is often treated by traders as a period where there isn't enough volatility to do much.

I started looking at it differently.

Instead of seeing the relatively quiet periods as useless, I started studying the ranges that formed and what happened around their highs and lows when liquidity increased later.

That research eventually became one of the foundations of the Goldmine Strategy.

The strategy evolved around the idea that time and price need to be studied together.

The same price pattern can mean something very different depending on when it occurs.

That became an important principle in my trading framework.

The strategy wasn't created overnight

This wasn't a situation where I wrote down ten rules one afternoon and called it a strategy.

It evolved through observation, testing, modification and repetition.

Some ideas worked.

Some didn't.

Some looked good on historical charts but didn't hold up when I tested them more carefully.

That process forced me to become much more selective.

Eventually, the framework became more structured.

Instead of simply saying:

"Gold usually does this."

I wanted rules that could answer:

When do we trade?

What qualifies as a setup?

Where is the invalidation point?

Where does the trade make sense?

When should we stay out?

How much should we risk?

That transition — from observation to rules — was probably the most important part of developing the strategy.

Then I gave it a name

At some point, I realized that I wasn't just working with disconnected trading ideas anymore.

There was a framework.

So I gave it a name:

The Goldmine Strategy.

The name made sense because the entire concept was built around finding specific conditions in Gold rather than trying to trade every movement in the market.

And giving the strategy a name changed something else.

It made it easier to build around.

I could write about it.

I could teach it.

I could improve it.

I could build tools around it.

And eventually, I could turn the methodology into software.

Then something interesting happened online

I started publishing content around the strategy.

Articles about Gold trading.

Asian-session trading.

XAUUSD price action.

Liquidity.

Market structure.

The Goldmine Strategy itself.

Over time, the name started appearing across more of my content.

I've published multiple Goldmine-related articles online, including content specifically explaining the strategy and its approach to XAUUSD.

Some of those articles have also been distributed beyond my own website, which helped me realize something important:

A trading strategy can become a product brand.

It doesn't have to remain a PDF or a collection of rules.

It can become an ecosystem.

Google made me think about the idea differently

One thing I've been paying close attention to is how people discover trading information through search.

People don't necessarily search for the exact product you built.

They search questions.

Things like:

What is the best Gold trading strategy?

How do I trade XAUUSD?

What is a good Asian-session strategy?

How does a Gold trading bot work?

What is an XAUUSD EA?

That made me realize that building the product and building the information around the product are two different things.

The strategy needs to exist as an actual methodology.

But people also need to be able to discover the ideas behind it.

That's why content became an important part of the Goldmine journey.

From strategy to software

The next logical question was:

Can the strategy be automated?

That led to Goldmine becoming more than a trading methodology.

We're now developing the strategy into automated trading technology through an MT5 Expert Advisor.

That's a completely different challenge.

A human trader can interpret a chart.

Software can't "kind of understand" a setup.

You have to define it.

You have to turn concepts into rules.

You have to decide what the system does when conditions aren't perfect.

You have to test those rules.

And you have to accept that automated trading doesn't eliminate market risk.

That process has actually made me rethink parts of the original strategy.

Building software forces you to be precise.

The unexpected lesson

The biggest lesson I've learned from the Goldmine journey isn't actually about trading.

It's about product development.

A product can start as an idea.

Then become a framework.

Then become content.

Then become a brand.

Then become software.

And each stage forces you to understand the original problem more deeply.

That's what happened with Goldmine.

It started with me studying Gold.

Then I developed a repeatable trading framework.

Then I named it.

Then I started publishing it.

Then people started discovering the content.

Then I started building software around it.

And now I'm thinking about what the larger Goldmine ecosystem could become.

But popularity isn't the same thing as proof

This is something I want to be very clear about.

Seeing a strategy name appear online doesn't prove that the strategy is profitable.

Search visibility doesn't prove profitability either.

And a backtest doesn't guarantee future results.

Those are things I've become much more conscious of as Goldmine has grown.

The goal isn't to convince everyone that Goldmine is some magical system.

The goal is to build something useful, test it honestly and keep improving it.

What's next?

The strategy is now becoming a broader product ecosystem.

The current direction includes:

Goldmine Strategy

→ the trading methodology

Goldmine Indicator

→ tools for analyzing the market

Goldmine Trading Bot

→ automated execution through MT5

And potentially more tools around systematic Gold trading in the future.

That's the part I'm most excited about.

What started as a trading idea is becoming a product company.

And I'm still figuring out where it can go.

I'd love to hear from other Indie Hackers:

Have you ever taken something you originally built for yourself and turned it into a product or brand?

How did you know when the original idea was strong enough to build a business around it?