Trojan & Maestro vs a Custom Solana Bot: Real Cost

A 1% fee on a $200,000 monthly trade volume is $2,000 gone before you count slippage, priority fees, or a single losing position. That's the number most people renting Trojan or Maestro never actually add up, because it comes out of each swap invisibly and nobody sends you an invoice at the end of the month. So let's add it up properly, and figure out where the math flips in favor of writing your own.

What you're actually paying for

Trojan and Maestro both charge on a per-trade basis. Depending on your referral tier and holdings, that's typically somewhere between 0.5% and 1% of the notional value of every buy and sell. Maestro also runs a $200/year premium tier that trims the fee and adds features like copy-trading and a private RPC. Trojan leans on referral discounts. Either way, the fee is a percentage of volume, not a flat cost, and that single fact drives the entire decision.

The fee buys you three things that are genuinely non-trivial to replicate:

• A hosted mempool/transaction pipeline with Jito bundle submission already wired in.
• Wallet management and key custody handled inside a Telegram bot, so you never touch a private key.
• A team that patches the thing when Solana ships a breaking change to the transaction format or a DEX migrates its program.

That last point is worth respecting. When Pump.fun changed its bonding-curve program, off-the-shelf bots had it working again within hours. If you'd rolled your own, that was your Saturday.

But you're also buying shared infrastructure, and shared infra has costs that don't show up as a line item. Your transactions go out through the same RPC endpoints and the same Jito tip accounts as thousands of other users. During a hyped launch, that pipeline is congested with your competitors' orders. You are, quite literally, racing people who are using the identical bot you are, landing through the identical bundle path.

The break-even math

Here's the part that matters. A custom bot has a large upfront cost and a small, fixed monthly cost. A rented bot has near-zero upfront cost and a variable cost that scales with your volume. They cross at a specific point.

Rough, honest numbers for a production-grade custom Solana bot:

• Build: $15,000–$40,000 for a sniper with mempool watching, Jito bundling, retry logic, and a real position manager. Call it $25k for a solid mid-range build.
• Infra: a dedicated RPC (Helius or Triton) plus a co-located node or a low-latency VPS near the validators runs $500–$1,500/month.
• Maintenance: budget 10–20% of build cost per year for keeping up with protocol changes.

Now put it against a 1% rented fee:

Rented monthly cost   = 0.01 * monthly_volume
Custom monthly cost   = infra + amortized_build + maintenance

At $1M/month volume:
  Rented  = 0.01 * 1,000,000 = $10,000 / month
  Custom  = ~$1,000 infra + (~$25,000 / 18mo) ≈ $1,000 + $1,400 + ~$400 maint
          ≈ $2,800 / month

At a million dollars a month in volume, the custom bot is roughly a third of the cost, and it pays back the entire build in the first two to three months. Below about $150k–$250k/month in round-trip volume, renting is clearly cheaper and you shouldn't even think about building. The gray zone is the $250k–$700k band, where the answer depends on how long you plan to run and how much the latency edge is worth to you.

The volume figure is round-trip, by the way. A buy and its eventual sell are two taxable events for the fee. People consistently underestimate their real volume by half because they only count entries.

Latency is the hidden term

The break-even chart assumes cost is the only variable. It isn't. On competitive launches, landing your bundle 40ms earlier is the difference between the fill you wanted and buying the top of someone else's exit. A shared bot can't give you dedicated tip strategy or a private transaction path, and the routing choices it makes are averaged across its whole user base, not tuned to you.

If you're serious about landing edge, the relevant question isn't Trojan versus Maestro — it's how your bundles reach validators at all. We wrote up the tradeoffs between the two dominant paths in bloXroute versus Jito for MEV bundle landing, and the choice there moves your win rate more than the bot's UI ever will. A custom build lets you A/B the two routes and pick per-launch; a rented bot picks for you.

Compute matters too. If your strategy touches on-chain programs — an LP rebalancer, an arb executor — the runtime you compile against changes how many compute units you burn per instruction, which changes what you can fit in a single transaction. Our breakdown of Anchor versus Pinocchio for HFT compute budgets gets into why that's not a cosmetic choice. None of this is tunable on a rented platform.

What a build actually looks like

A minimal sniper loop is not mysterious. The shape is roughly:

// pseudo-flow, not production
let sig = watch_mempool()          // subscribe to new-pool / migration events
    .filter(passes_safety_checks)  // mint authority, LP lock, honeypot sim
    .map(build_buy_ix)             // route through the right AMM program
    .map(|ix| bundle_with_tip(ix, dynamic_tip()))
    .and_then(submit_via_jito);    // + fallback to normal RPC on bundle drop

The hard parts aren't in that outline. They're the safety simulation that stops you buying a honeypot, the dynamic tip model that doesn't overpay on quiet blocks, and the retry logic that doesn't double-buy when a bundle silently drops. That's where the $25k goes, and it's why a two-week clone off GitHub loses money. If you're weighing a build, a short strategy consultation will tell you honestly whether your volume justifies it before you spend a cent on engineering.

If you already have code

Plenty of people arrive with a bot a freelancer wrote that "mostly works." The usual finding is that it's landing 60% of the bundles it should because the tip logic is naive or it's serializing transactions inefficiently. A focused code review and audit tends to recover more edge per dollar than a full rewrite, and it's the first thing I'd do before assuming you need to start over.

The honest recommendation

If you trade under a few hundred thousand a month and value your weekends, rent. Trojan and Maestro are well-built and the fee is a fair price for not maintaining infrastructure. The moment your volume clears roughly $500k/month, or the moment latency starts costing you fills you can measure, the percentage fee becomes the most expensive line in your operation and a dedicated Solana sniper with your own RPC and tip strategy starts to look cheap.

The same logic extends beyond sniping. If you're running market-making size, the fee-versus-control calculus is even sharper — a Hyperliquid market maker build pays for itself faster than most people expect once quoting volume scales, and the LP-strategy tradeoffs we covered in the Meteora DLMM versus Orca Whirlpools comparison compound on top of that.

Run your own volume through the break-even math above before you decide anything. If the number lands in the gray zone and you're not sure which way it tips, talk it through with us and we'll tell you straight whether to build or keep renting.