This content is for educational and informational purposes only and should not be construed as investment advice, a recommendation, or an offer to buy or sell any securities or cryptocurrencies. Any strategies discussed are illustrative only and may not be suitable for all investors. This article reflects the experience of an individual user, is not representative of all customers, and should not be considered an endorsement or guarantee of future performance. The views and opinions expressed are those of the author and do not reflect or represent the views and opinions of Alpaca. Alpaca does not recommend any specific securities or investment strategies. The author was not compensated for this content but did receive nominal promotional items from Alpaca.
I'm Not a Programmer
I want to get that out of the way early because it matters for everything that follows.
My background is in fund strategy, digital assets, AI enablement, and operational infrastructure for investment managers. I have spent most of my career thinking about how emerging technology changes the way capital gets allocated. I don't spend my time writing Python scripts or debugging TypeScript compilers.
But about three months ago, I had a problem that wouldn’t go away. I kept having investment ideas that I could not test fast enough. I would read something about mean reversion in oversold equities, or notice a pattern in how Bitcoin behaves during low-liquidity hours, and the same question kept surfacing: that sounds right, but how do I actually know?
The answer used to be: open a spreadsheet, pull some data manually, squint at it, and make a judgment call. That is fine for one idea. It is not fine for six.
So I did something that would have seemed absurd to me a year ago. I sat down with an AI coding assistant and started building a systematic trading system from scratch.
No prior programming experience. No quant background.
Just a clear idea of what I wanted the system to do and the patience to iterate until it worked.
Three months later, I have six trading strategies running in a paper trading environment* across two asset classes, an interactive backtesting dashboard that pulls live data from Alpaca's Trading API, and a set of autonomous agents that execute trades, manage risk, and report results via Discord. All without me touching a single order ticket.
This is the story of how that happened, and how I used Alpaca as part of the build.
The Problem: Intuition Does Not Scale
I named my first trading bot after Warren Buffett. Not because I think I'm Warren Buffett (I'm very much not), but because the strategy was built on his core principles: identify undervalued assets, buy with conviction, and let compounding do the work.
The bot started in digital assets. It scanned tokens using a scoring system based on fundamental metrics (liquidity, volume trends, price relative to moving averages) and made autonomous buy and sell decisions. It helped validate the initial idea, but it also surfaced a question I was not expecting:
Do the specific metrics Buffett used to identify undervaluation 50 or 60 years ago actually map onto a market that looks completely different today?
The businesses trading at the highest valuations right now are not the asset-heavy industrial companies that classic value screens were designed to identify. They are software platforms with near-zero marginal costs, network effects that compound without capital investment, and earnings power that traditional P/E ratios were never built to capture. A stock that looks expensive by 1970s value metrics might be genuinely undervalued by any reasonable forward-looking measure.
I'm not saying Buffett was wrong. The world my bot is operating in is structurally different from the world those principles were developed in. The real work is figuring out how to adapt the spirit of the framework without losing the discipline that makes it useful.
The realization that one strategy is not enough and that you need a way to rapidly test and compare approaches, is what pushed me toward building a real backtesting infrastructure. And that’s where Alpaca came in.
Why Alpaca
I evaluated several broker APIs before settling on Alpaca, and the decision came down to a few things that mattered more than I expected.
First, the data. Alpaca provides two-plus years of daily OHLCV data through their Market Data API at no cost. When you are backtesting six strategies across multiple symbols, you burn through a lot of historical data. Paying per request would have killed the project before it started.
Second, paper trading that mirrors live execution. Alpaca's paper trading environment uses the same API endpoints, the same order types, and the same market data as their live accounts. Every trade my bot places in paper mode goes through the exact same code path it would in production.
Think of it as a flight simulator: same instruments, same conditions, no actual stakes. When I'm ready to go live, it is literally a one-line configuration change.
Third, a REST API that does not require a PhD. I did not want to install a heavyweight SDK or learn a proprietary query language. Alpaca's Trading API is standard REST. You make HTTP requests, you get JSON back. My entire Alpaca client is a single TypeScript file with zero external dependencies. That matters when you are building with AI assistance, because simpler code means fewer things that can go wrong.
And finally, commission-free trading** for small positions. When you are running a systematic strategy on a $500 seed account with 3 to 5 percent position sizes, commissions can eat you alive. Alpaca's zero-commission structure means I can test strategies with realistic position sizes without the fee drag distorting my results.
I also recently connected Alpaca's MCP (Model Context Protocol) Server, which lets my AI assistant query account data, positions, and market information directly during research sessions. It is a small thing, but it collapses the loop between wondering how a position is doing and actually knowing.
Alpaca's paper trading environment uses the same API structure as live trading. However, paper trading does not fully replicate live market conditions, and differences such as liquidity, slippage, and execution quality may impact real-world results.
The Dashboard: Where All of This Comes Together
This is the piece I want to spend the most time on, because it is the piece that changed how I think about strategy development.
When I started backtesting, I was running scripts manually. Give the engine a strategy, a start date, a set of assets, and a parameter configuration. Wait for it to crunch. Look at the output. Change one number. Run it again. That is working hard, not smart.
So the next step was turning the backtesting engine into an interactive dashboard. And because Alpaca's Market Data API returns clean, well-structured JSON, the data pipeline from their servers to my interface was surprisingly straightforward to build. No custom parsing. No data cleaning headaches. Just request the bars, transform them into the format my engine expects, and run the simulation.
What the dashboard does. You load it up, toggle between Equities and Crypto at the top, select your symbols, set a date range and initial capital, and the system pulls historical data directly from Alpaca's Trading API. It then simulates every trade the strategy would have made over that period and displays the results in real time.
The equity curve at the top tells the visual story. You can see the strategy's path relative to the benchmark over two years, including a rough stretch in mid-2025 where drawdown deepened before recovering. That kind of visualization is what separates backtesting from guessing. I don’t just see the final number, I see the path the strategy took to get there, and whether you could have stomached the ride.
The sliders are where it gets interesting. On the left side of the dashboard, you can see the strategy parameters: RSI Buy Threshold, Dip Below SMA, Min Entry Score, Trailing Stop percentage. Each of those is adjustable. Move a slider, and the entire simulation reruns instantly. The equity curve reshapes itself, the performance metrics update, and the trade log reflects the new parameter set.
This is the difference between thinking you know what a parameter change does and seeing it. When you watch your Sharpe ratio drop from 0.8 to 0.3 because you widened your stop-loss by two percentage points, you develop an intuition for risk management that no textbook can provide.
It works for crypto too. Toggle from Equities to Crypto at the top of the dashboard, and the same infrastructure applies to digital assets. The interface, the metrics, and the simulation engine are identical. What changes is the data source and the strategy logic underneath. The crypto strategies are designed for a different market structure (higher volatility, 24/7 trading, different liquidity profiles), but the evaluation framework is the same. That consistency matters. It means I can compare strategies across asset classes using the same language and the same risk metrics.
A word of caution on backtesting. It is seductive. Very easy to keep moving sliders until you find a configuration that looks amazing on historical data. That is called overfitting, and it is the fastest way to lose money in live trading. The parameters that produced the best backtest are almost certainly not the parameters that will produce the best live results. The dashboard is a tool for building intuition, not for finding a magic formula. Additionally, backtested results may overstate performance because they are developed with full knowledge of past market conditions. Strategies that perform well in backtests may not perform similarly in live trading.
Under the Hood: How Alpaca's Trading API Powers the Dashboard
I want to share some of the technical architecture without giving away the strategy logic, because I think it is useful for anyone considering building something similar.
The data pipeline works in three stages.
Stage 1: Data ingestion.
The dashboard makes REST calls to Alpaca's Market Data API to pull historical bars (daily OHLCV data) for whatever symbols the user has selected. The request is straightforward: specify the symbols, the timeframe, and the date range. Alpaca returns clean JSON with timestamps, open, high, low, close, and volume for each bar. No authentication beyond an API key. No complex query syntax. This is the foundation that everything else builds on.
Stage 2: Signal computation.
This is the proprietary layer that I'm deliberately keeping vague. The raw price data flows through a series of technical indicators and scoring functions that produce entry and exit signals. What I will say is that the system uses a composite scoring approach (multiple indicators weighted together rather than any single trigger), regime detection to determine market conditions, and dynamic thresholds that adjust based on volatility. The specific indicators, weights, and thresholds are the secret sauce.
Stage 3: Simulation and rendering.
The backtesting engine takes those signals and simulates execution, accounting for position sizing, slippage (configurable via a slider on the dashboard), trailing stops, and capital allocation limits. The results are rendered in real time using a reactive front end, so parameter changes propagate instantly through the entire pipeline.
The key architectural decision was keeping the Alpaca data layer completely separate from the strategy logic. That separation means I can swap in a different data source (and I do, for crypto) without touching the strategy code. It also means the dashboard is not locked into any single broker. Alpaca met my requirements for equities because their free data tier and paper trading environment fit my use case for this kind of development work.
For anyone thinking about building with Alpaca's Trading API specifically, a few technical notes. Their rate limits are generous enough that you will not hit them during normal backtesting. The IEX feed on the free tier provides sufficient granularity for daily strategies (if you need intraday, the SIP feed is available on paid tiers). And their WebSocket streaming API, which I use for live monitoring but not backtesting, is remarkably stable.
The Tech Stack
Before I get into the strategies themselves, it helps to see the full picture of what connects to what. The system is not one monolithic application. It is a set of specialized tools, each handling what it does best.
- Claude Code (Anthropic) is my AI co-developer. Not a chatbot that writes snippets on request, but a full coding partner that architects systems, writes implementation code, runs tests, and debugs alongside me in real time. This is the engine that made it possible for a non-programmer to build production-grade trading infrastructure.
- Alpaca Trading API is the execution and data layer for US equities. Paper trading for validation, live trading for deployment, and historical market data for backtesting. Three equity strategies run through Alpaca.
- Jupiter DEX API is the execution layer for digital assets on Solana. Jupiter aggregates liquidity across decentralized exchanges to find the best swap routes. The original Buffett Bot used this to trade tokens autonomously.
- Kraken API handles the Bitcoin-specific strategies via the ccxt library, with additional strategies planned for their futures platform.
- TypeScript and Node.js are the language everything is written in. I chose TypeScript over Python because Claude Code was more fluent in it, and the type safety catches bugs before they cost money. Every bot, every data pipeline, and every dashboard component is TypeScript end to end.
- Discord Webhooks are the notification layer. Every trade, every regime change, and every daily digest gets posted automatically. I check Discord instead of logging into trading platforms.
The important thing is that none of these tools required me to become an expert in any of them. Claude Code handled the implementation details. I handled the strategy and the "should we actually do this?" decisions.
That said, I’ve embraced an age old mentality when it comes to these tools: trust AND verify.
Building with AI: Co-Developer, Not Code Generator
Here is where my experience probably diverges from most people writing about algorithmic trading.
I did not write this system and then ask AI to review it. I built it with AI from the first line of code. Claude Code was my co-developer for the entire project. I described what I wanted the system to do in plain English, and we iterated together until it worked.
This isn’t the same as asking a chatbot to write you a script. Co-development means I describe the strategy logic ("when volatility is high, follow the trend; when it is low, fade the extremes"), the AI architects the system (file structure, data flow, error handling), I review what it built and push back ("that is too aggressive, add a cooldown after each trade"), and we test together, find the bugs, and fix them in real time.
The AI is excellent at the things I'm bad at: remembering syntax, structuring code cleanly, implementing error handling for edge cases I would never think of.
I'm better at the things the AI cannot do: knowing which strategies are worth testing, understanding when the market regime has shifted, and deciding when to stop optimizing and start trading.
What surprised me most is how fast this process moves. The backtesting dashboard, a fully interactive web application with live charts, performance metrics, and adjustable parameter sliders, took less than a day to build. Not because the AI did everything perfectly on the first try, but because the iteration cycle went from hours to minutes.
If you have ever spent an afternoon debugging a data pipeline, you understand what that speed means for your ability to test ideas.
From One Strategy to Six
Once the backtesting infrastructure was in place, a natural question emerged: if one strategy works in certain conditions, what happens when those conditions change?
Every trading strategy has a regime where it thrives and a regime where it struggles. A trend-following strategy performed well in this specific test, when markets are directional and gets chopped to pieces when they are range-bound. A mean-reversion strategy does great in calm markets and blows up during a sustained crash.
The insight, which is obvious in hindsight but took me a while to internalize, is that strategy diversification works exactly like asset diversification. You don't put all your money in one stock. You should not put all your alpha in one strategy.
So I built six. Overkill? Nah.
Three trade Bitcoin through a crypto exchange. Three trade U.S. equity indices through Alpaca. They are deliberately designed to be uncorrelated: when the crypto momentum strategy is struggling because Bitcoin is range-bound, the equity mean-reversion strategy might be thriving because the stock market is choppy. When volatility spikes and the cautious strategies step aside, the trend-followers step in.
Each strategy has its own capital allocation, its own risk limits, and its own performance tracking. They run as independent processes. If one crashes, the others keep going. They all report to the same Discord channel, so I can see every decision every bot makes in real time without logging into six different dashboards.
I'm not going to share the specific parameters or signal logic here (that is the proprietary part), but I will share the framework.
Regime detection matters more than signal detection. Before you decide what to trade, you need to know what kind of market you are in. I use volatility regime classification to determine whether the system should be following trends or fading them.
Cooldowns prevent revenge trading. After every position exit, the strategy enforces a mandatory waiting period before it can re-enter. This sounds simple, but it potentially eliminates a huge category of losses from re-entering bad trades.
Position sizing is where the risk management actually lives. The entry signal gets all the attention, but the position size determines whether a bad trade is a learning experience or a catastrophe. I use a modified Kelly criterion that keeps individual positions small relative to total capital. (For additional background on the Kelly criterion and its history, readers may refer to resources such as “Fortune’s Formula”).
What the Data Actually Showed
I want to share some results without overpromising.
Over a two-year simulated backtest period (January 2024 through February 2026), the equity strategies showed positive returns over the tested period, with drawdowns that varied over time. The crypto strategies showed higher volatility but also higher absolute returns, which is pretty much what you would expect.
The more interesting finding was what happened when I ran all six strategies together. In this simulated backtest, combining strategies resulted in a different risk/return profile, including periods of lower drawdowns compared to individual strategies. The max drawdown was lower. The Sharpe ratio was higher. Not because any single strategy got better, but because the losses from one strategy tended to coincide with gains from another.
That is the whole point. You are not trying to find the one perfect strategy. You are trying to build a portfolio of strategies that collectively perform better than any one of them alone.
Important: These results are based on backtesting (simulated performance) and do not represent actual trading results. Backtests have inherent limitations, including the benefit of hindsight, and may not reflect the impact of real market conditions such as liquidity constraints, slippage, or changing market dynamics. Actual results may differ materially.
Making It Actually Run
A backtested strategy that lives on your laptop is a science project. A strategy that runs autonomously, manages its own risk, and tells you what it did is infrastructure.
The operational layer includes autonomous execution (bots run as background services on a dedicated machine, starting automatically on boot and saving state to disk), Discord notifications for every trade and regime change, health monitoring that checks every five minutes that all bots are running, and circuit breakers that pause a strategy automatically if it hits a daily loss limit.
The whole system runs on a Mac Mini sitting on my desk. No cloud servers, no AWS bills, no DevOps team. When it is time to scale, the plan is to add a second machine for heavier computation. But for now, the Mini handles everything.
Lessons for Builders
If you are thinking about building something similar, here is what I wish someone had told me at the start.
- Start with paper trading. Actually start with it. Not as an afterthought, but as the primary environment for your first several weeks. Alpaca's paper trading environment is good enough that you will forget you are not trading real money. Validate your logic before you validate your conviction.
- Your first strategy will not be your best strategy. Build it anyway. The purpose of the first strategy is to build the infrastructure: the data pipeline, the execution layer, the risk management, the monitoring. Once that infrastructure exists, adding a second strategy is ten times faster than building the first one.
- Backtesting will lie to you if you let it. The best backtest result is almost always overfit. Test your strategy on data it has never seen. Change the parameters by 20% in both directions. If the strategy falls apart, it was not robust to begin with.
- AI is a force multiplier, not a replacement for thinking. Claude Code built 90% of my codebase. But the 10% that matters (which strategies to test, how to size positions, when to override the system) is still human judgment. AI makes you faster. It does not make you smarter. You still have to understand what you are building and why.
- Commissions and slippage are real. A strategy that returns 8% annually with 0.4% round-trip fees and realistic slippage is a very different proposition than the same strategy in a frictionless backtest. Alpaca's zero-commission structure can help reduce certain costs, but you still need to account for bid-ask spreads and market impact.
The above reflects the author’s personal experience and is provided for informational purposes only. It is not intended as investment advice or a recommendation of any trading strategy, methodology, or approach. Individual results may vary, and strategies discussed may not be suitable for all investors.
Building in Public
Most people building trading systems do it in private. There are good reasons for that. You don't want to broadcast your edge. But I have been publishing weekly updates on this project since the beginning, and I think the transparency has been more valuable than the secrecy would have been.
Accountability forces rigor. When you know you are going to write about what happened this week, you cannot hand-wave past a bad result. You have to explain it. That explanation (why did the bot take that trade? was the logic sound even though it lost money?) is where most of the actual learning happens.
The community has been an unexpected asset. My BitFinance newsletter readers have sent me more useful questions than I would have generated on my own. "What happens when VIX spikes and your mean-reversion strategy is fully allocated?" is the kind of question that leads to building a circuit breaker you did not know you needed.
There is a distinction between sharing what you are building and sharing how it works. I talk openly about the architecture, the process, the mistakes, and the results. I don't publish the signal logic, the specific parameters, or the entry/exit thresholds. The framework is educational. The implementation is proprietary.
This article exists because I wrote publicly about building with Alpaca's API, and that caught the attention of their team. Building in public is not just documentation. It is a form of networking with people who are working on similar problems.
If you are building something and debating whether to share it: share the process. Keep the secret sauce. You will be surprised what comes back.
What’s Next?
The system is live in paper trading on Alpaca and approaching live deployment with real (small) capital on both the equity and crypto sides. The plan is to start with $500 per venue. Enough to generate real signals with real execution, not enough to lose sleep over.
Paper Trading vs. Live Trading: A Data-Backed Guide on When to Start Trading Real Money
From there, the focus is on live validation (comparing live results to backtest projections and figuring out the gaps before scaling), continuous strategy refinement using the dashboard, expanded asset coverage across more symbols and asset classes, and eventually multi-agent orchestration where strategies coordinate capital allocation based on which regime each one is operating in.
The longer-term vision is a set of autonomous agents, each managing a different strategy on a different asset class, dynamically adjusting based on market conditions. The backtesting dashboard is the interface that makes that scalable without requiring a human to manually validate every decision.
Resources
If you want to start building your own systematic trading system, here are the resources I found most useful:
Alpaca Trading API (docs.alpaca.markets/docs/trading-api) is the place to start. The paper trading quickstart will have you placing simulated orders quickly.
Alpaca Market Data API (docs.alpaca.markets/docs/about-market-data-api) provides the historical and real-time data that powers everything. The free tier (IEX feed) is more than enough to get started.
Alpaca Paper Trading (docs.alpaca.markets/docs/paper-trading) lets you set up a paper account in minutes. Same API, same execution, no risk.
For language, either TypeScript or Python works. I used TypeScript because my AI co-developer was more fluent in it. Python has more quant libraries. Pick whichever you are more comfortable reading.
The concepts that matter most are regime detection (how to classify market conditions), mean reversion vs. momentum (the two fundamental edges in systematic trading), and position sizing (Kelly criterion, risk parity). These matter more than any specific indicator.
About the Author
Matthew Snider is the founder of BitFinance and a principal at Block3 Strategy Group, where he focuses on digital asset strategy, AI enablement, and systematic trading infrastructure..
*The Paper Trading API is offered by AlpacaDB, Inc. and does not require real money or permit a user to transact in real securities in the market. Providing use of the Paper Trading API is not an offer or solicitation to buy or sell securities, securities derivative or futures products of any kind, or any type of trading or investment advice, recommendation or strategy, given or in any manner endorsed by AlpacaDB, Inc. or any AlpacaDB, Inc. affiliate and the information made available through the Paper Trading API is not an offer or solicitation of any kind in any jurisdiction where AlpacaDB, Inc. or any AlpacaDB, Inc. affiliate (collectively, “Alpaca”) is not authorized to do business.
**Commission free trading is available to Alpaca's retail customers. Commission free trading means that there are no commission charges for Alpaca self-directed individual cash brokerage accounts that trade U.S.-listed securities and options through an API. However, certain arrangements with authorized business partners or the use of the Elite Smart Router as part of the Alpaca Elite offering may preclude commission free trades by Alpaca Securities. Please refer to the Brokerage Fee Schedule for more information. Relevant regulatory fees may apply. Alpaca reserves the right to charge additional fees if it is determined that order flow is non-retail in nature.
Please note that this article is for educational and general informational purposes only. The examples above are for illustrative purposes only. The views and opinions expressed are those of the author and do not reflect or represent the views and opinions of Alpaca. Alpaca does not recommend any specific securities or investment strategies. Testimonials and examples used are for illustrative purposes only and are not indicative of future performance or success.
Alpaca and the entities referenced in this article are not affiliated and are not responsible for the liabilities of the others.
Alpaca does not prepare, edit, or endorse Third Party Content. Alpaca does not guarantee the accuracy, timeliness, completeness or usefulness of Third Party Content, and is not responsible or liable for any content, advertising, products, or other materials on or available from third party sites.
Past hypothetical backtest results do not guarantee future returns, and actual results may vary from the analysis.
All investments involve risk, and the past performance of a security, or financial product does not guarantee future results or returns. There is no guarantee that any investment strategy will achieve its objectives. Please note that diversification does not ensure a profit, or protect against loss. There is always the potential of losing money when you invest in securities, or other financial products. Investors should consider their investment objectives and risks carefully before investing.
Cryptocurrency is highly speculative in nature, involves a high degree of risks, such as volatile market price swings, market manipulation, flash crashes, and cybersecurity risks. Cryptocurrency is not regulated or is lightly regulated in most countries. Cryptocurrency trading can lead to large, immediate and permanent loss of financial value. You should have appropriate knowledge and experience before engaging in cryptocurrency trading. For additional information please click here.
Securities brokerage services are provided by Alpaca Securities LLC ("Alpaca Securities"), member FINRA/SIPC, a wholly-owned subsidiary of AlpacaDB, Inc. Technology and services are offered by AlpacaDB, Inc.
Cryptocurrency services are made available by Alpaca Crypto LLC ("Alpaca Crypto"), a FinCEN registered money services business (NMLS # 2160858), and a wholly-owned subsidiary of AlpacaDB, Inc. Alpaca Crypto is not a member of SIPC or FINRA. Cryptocurrencies are not stocks and your cryptocurrency investments are not protected by either FDIC or SIPC. Please see the Disclosure Library for more information.
This is not an offer, solicitation of an offer, or advice to buy or sell securities or cryptocurrencies or open a brokerage account or cryptocurrency account in any jurisdiction where Alpaca Securities or Alpaca Crypto, respectively, are not registered or licensed, as applicable.