DEV Community: Ray

I Ran 10 Trading Strategies for 30 Days — Here Is What Actually Worked

Ray — Tue, 31 Mar 2026 00:26:32 +0000

I Ran 10 Trading Strategies for 30 Days — Here's What Actually Worked

I built a paper trading framework, ran 10 different algorithmic strategies through it for a full month, and the results were... humbling.

Some strategies I expected to crush it. Most didn't. One I almost skipped ended up being the standout.

Here's the unfiltered breakdown.

The Setup

I built TradeSight (https://github.com/rmbell09-lang/tradesight) specifically for this kind of systematic testing. It's a Python paper trading framework that connects to Alpaca's paper API, runs strategies against live market data without real money, and tracks every metric I care about: win rate, max drawdown, Sharpe ratio, average trade duration.

Test period: 30 days. Universe: S&P 500 components. Capital: $100k paper.

The Strategies

I ran 10 total but I'll focus on the ones with interesting results.

The Winners

Bollinger Band Mean Reversion

Win rate: 61%
Max drawdown: 8.2%
Sharpe: 1.34

This was the surprise. Mean reversion on the 2-hour chart, buying oversold bounces at the lower band with a tight stop. The key was filtering to stocks with high relative volume — it kept me out of the low-liquidity traps that kill this strategy.

RSI + MACD Confluence

Win rate: 58%
Max drawdown: 11.3%
Sharpe: 1.12

Classic setup but it works. I only take trades when RSI is below 35 and MACD is crossing bullish. The confluence filter cut trade frequency by 60% but also cut losers proportionally more. Quality over quantity.

The Middle of the Pack

Simple momentum (20-day breakout): 52% win rate, Sharpe 0.71. Works in trending markets, gets destroyed in chop. March was choppy. Neutral verdict.

VWAP reversion: 54% win rate but average winner smaller than average loser. Positive expectancy only in high-volatility environments.

The Failures

RSI divergence: 44% win rate, -14.7% max drawdown. I thought spotting divergence would be a signal edge. It wasn't. Divergences resolve in the wrong direction more than you'd expect in a momentum-heavy tape.

Earnings momentum: I had high hopes. Buy stocks gapping up post-earnings, hold for continuation. Reality: 41% win rate, brutal drawdown when gaps filled. The few big winners didn't overcome the frequent reversals.

Pure momentum (highest RS stocks, long-only): 48% win rate but the distribution was brutal — lots of small losses, occasional big winners. Psychologically hard to stick with even in a paper account.

The Metrics That Actually Matter

After 30 days, I stopped caring about win rate as a primary metric. Here's what I track now:

Expectancy = (Win Rate × Avg Win) - (Loss Rate × Avg Loss)

A 45% win rate strategy can outperform a 60% win rate strategy if the winners are 3x the size of losers. The confluence RSI+MACD strategy had a 2.4:1 reward-risk ratio. The divergence strategy had 0.8:1. That explains everything.

Max Drawdown as % of initial capital: I set a kill switch at 15%. Two strategies hit it and got shut down automatically. This feature alone made TradeSight worth building — letting losing strategies run is how you blow up accounts.

Sharpe ratio across the test period: anything above 1.0 I consider worth continuing to live paper test. Below 0.5? Shelved.

What I'm Testing Next

The Bollinger mean reversion strategy is going into extended testing. I want to see if it holds up across different market regimes — specifically a trending environment vs. the sideways chop of the past month.

I'm also building a sector rotation overlay. The hypothesis: most of these strategies perform better when you're only playing the 2-3 sectors with the strongest relative strength. More filtering, fewer but higher-quality setups.

Try It Yourself

TradeSight is open source and the setup is straightforward:

git clone https://github.com/rmbell09-lang/tradesight
cd tradesight
pip install -r requirements.txt
cp .env.example .env
# Add your Alpaca paper trading API keys
python main.py --strategy bollinger_reversion

The paper trading account is free through Alpaca. You can run this on a $5 VPS and leave it running indefinitely with no financial risk.

The strategies I tested are in /strategies/. They're modular — you can copy one, modify the entry/exit logic, and run it as a new strategy without touching the core engine.

30 days of data isn't a definitive sample, but it's enough to kill the bad ideas before they cost real money. That's the whole point.

Try TradeSight on GitHub: https://github.com/rmbell09-lang/tradesight

If you've run systematic strategy tests, I'd love to hear what you've found. Comment below.

Stop Paying for Monitoring: The Self-Hosted Stack for Indie SaaS Founders

Ray — Tue, 31 Mar 2026 00:26:22 +0000

Stop Paying for Monitoring: The Self-Hosted Stack for Indie SaaS Founders

I'm going to say the quiet part loud: most indie SaaS founders are wildly overpaying for monitoring.

I was too. Then I stopped.

Here's what I was running before I built my own stack:

Datadog: ~$15/host/month (that's the "cheap" tier)
PagerDuty: $21/user/month
Baremetrics: $129/month to see my own Stripe data

That's $165+ every single month before I made a single dollar. For a solo founder? That's obscene.

The Real Cost Problem

The monitoring industry is built for teams. Datadog's pricing assumes you have 10+ engineers who need dashboards, alerts, runbooks, and incident management workflows. PagerDuty's on-call rotation features are genuinely useless if you're the only person getting paged.

For indie hackers and small SaaS shops, we don't need enterprise observability. We need:

Know when the app is down
Know when something weird is happening with billing
Know the basic health metrics without a PhD in PromQL

The Self-Hosted Stack

Here's what I run now, total cost: $0 (beyond VPS that I already pay for).

Uptime Kuma — replaces StatusPage, Uptime Robot, etc. Runs on your VPS, beautiful UI, Telegram/Slack/email alerts. 5 minute setup. Free.

Netdata — replaces Datadog for host metrics. Lightweight, real-time, runs on the same VPS. The free tier covers everything a solo founder needs.

BillingWatch — this one I built myself because nothing else did what I needed. It's a self-hosted Stripe anomaly detector that watches for: sudden revenue drops, subscription spikes, unusual refund patterns, card decline surges. Runs as a lightweight Python daemon, connects to your Stripe webhook, alerts you on Slack or email when something looks off.

The gap I kept hitting was: Stripe sends you raw webhook data, but it doesn't tell you when something trends in a bad direction. BillingWatch does pattern analysis over your event stream and fires alerts based on configurable thresholds.

Real Numbers

Before: $165/month in monitoring tools
After: $0/month

Time to set up the full stack: about 3 hours (most of that was Netdata configuration)

What I gave up: fancy dashboards nobody looks at, on-call rotation features for a team of one, and Baremetrics charts I could build in 20 lines of Python.

What I kept: knowing when things break, knowing when billing looks weird, peace of mind.

The BillingWatch Setup

Since this one isn't as well-known as Uptime Kuma, here's the quick version:

git clone https://github.com/rmbell09-lang/billingwatch
cd billingwatch
pip install -r requirements.txt
cp .env.example .env
# Add your Stripe webhook secret and Slack webhook URL
python main.py

You configure thresholds in config.yaml:

alerts:
  revenue_drop_percent: 30  # alert if MRR drops 30% in 24h
  refund_spike_count: 5     # alert if 5+ refunds in 1 hour
  churn_rate_daily: 0.05    # alert if daily churn exceeds 5%

Point your Stripe dashboard at the BillingWatch webhook endpoint and you're done. It runs headlessly, stores nothing sensitive, and fires to your Slack channel when thresholds are crossed.

The Broader Point

The SaaS monitoring market optimizes for ACV, not indie founders. Every tool is priced assuming a sales conversation and a multi-seat contract.

Building your own stack with open-source tools isn't a compromise — for our use case, it's genuinely better. Simpler, faster to configure, no vendor lock-in, and you actually understand what it's doing.

If you're paying $100+/month to monitor a one-person SaaS, stop. The open-source alternatives are legitimately good now.

BillingWatch is open source on GitHub: https://github.com/rmbell09-lang/billingwatch — give it a star if this was useful.

Questions about the setup? Drop them in the comments.

Self-Hosted Stripe Billing Monitor vs PagerDuty: Real Cost Breakdown

Ray — Mon, 30 Mar 2026 23:27:26 +0000

Self-Hosted Stripe Billing Monitor vs PagerDuty: Real Cost Breakdown

======================================================

As an SRE or indie SaaS developer, you've probably encountered the issue of monitoring billing activity for your platform. While tools like PagerDuty are often touted as the ultimate solution, they come with a hefty price tag that can quickly add up at scale.

In this article, we'll explore the real cost breakdown between self-hosted solutions and managed services like PagerDuty using BillingWatch as an example. By the end of this article, you'll have a clear understanding of what to expect in terms of setup complexity, alerting features, multi-tenant support, and webhook monitoring.

Setup Complexity

Self-hosted solutions like BillingWatch require some technical expertise to set up, but they offer unparalleled flexibility and customization options. With BillingWatch, you can run the entire application on a VPS, eliminating the need for expensive managed services. This not only saves you money but also gives you complete control over your infrastructure.

Alerting Features

When it comes to alerting features, both self-hosted solutions like BillingWatch and managed services like PagerDuty have their strengths and weaknesses. BillingWatch allows for custom alerting using webhooks, which can be easily integrated with existing monitoring tools. On the other hand, PagerDuty offers a more comprehensive set of features out of the box, but at a higher cost.

Multi-Tenant Support

For platforms that serve multiple clients or customers, multi-tenant support is a critical feature to have. BillingWatch makes it easy to implement this by allowing you to define separate tenants with their own billing plans and subscriptions. While PagerDuty also offers multi-tenant support, its costs can quickly add up as your platform grows.

Webhook Monitoring

Lastly, when monitoring billing activity for multiple clients or customers, webhook monitoring is essential. BillingWatch makes it easy to set up webhooks that notify you of any changes in billing status, allowing you to respond promptly and prevent potential issues from arising.

To get started with BillingWatch, check out its GitHub repository at https://github.com/rmbell09-lang/billingwatch. With this self-hosted solution, you can save thousands of dollars per year compared to managed services like PagerDuty while still enjoying robust alerting features, multi-tenant support, and webhook monitoring.

References:

BillingWatch GitHub Repository

Tags: devops, programming, python, webdev

5 Things Paper Trading Taught Me That Backtesting Can't

Ray — Mon, 30 Mar 2026 23:26:59 +0000

5 Things Paper Trading Taught Me That Backtesting Can't

====================================================

As a quant beginner, I've spent countless hours studying trading strategies and backtesting them using popular libraries like TradeSight. However, there's one aspect of trading that backtesting often falls short: the reality of slippage.

Slippage Reality

Slippage is the difference between the expected price of a trade and the actual price at which it executes. Backtesting can't account for this because it assumes perfect execution, but in reality, markets move and prices fluctuate. TradeSight's implementation of slippage modeling helps to bridge this gap. For instance, you can configure it to simulate different slippage scenarios using parameters like slippage_type and slippage_amount. By incorporating this feature into your backtesting workflow, you'll get a more accurate picture of your strategy's performance in the wild.

Emotional Discipline Simulation

Another critical aspect that paper trading can teach you is emotional discipline. When you're trading with real money, fear and greed can quickly take over, leading to impulsive decisions that tank your portfolio. Paper trading allows you to practice making trades without risking actual capital. TradeSight makes this process even more realistic by simulating order fills, allowing you to see how different scenarios play out.

Live Data Quirks vs Historical

Backtesting often relies on historical data, which can lead to differences between the simulated and real-world performance of your strategy. However, when using TradeSight, you can run your backtests against live data streams, giving you a more accurate representation of how your strategy will perform in the current market conditions.

Order Fill Variability

When trading with real money, you'll inevitably face order fill variability – the difference between the expected price and the actual price at which your trades execute. Backtesting can't account for this because it assumes perfect execution, but TradeSight helps by simulating different order fill scenarios. This allows you to fine-tune your strategies to perform better in real-world conditions.

Strategy Confidence Calibration

Lastly, paper trading and backtesting can help you calibrate the confidence level of your strategies. By testing multiple iterations with varying parameters, you'll gain a deeper understanding of what works and what doesn't. TradeSight makes this process even more effective by allowing you to visualize performance metrics and make data-driven decisions.

To get started with TradeSight, check out its GitHub repository at https://github.com/rmbell09-lang/tradesight. With this library, you can take your trading strategies from backtested to live-traded, armed with the knowledge of how they'll perform in real-world conditions.

References:

TradeSight GitHub Repository

Tags: python, programming, fintech, trading

"Why Your Paper Trading Backtests Are Lying to You (And How to Fix It)"

Ray — Mon, 30 Mar 2026 15:30:27 +0000

Why Your Paper Trading Backtests Are Lying to You (And How to Fix It)

You ran the backtest. The Sharpe ratio looks great. CAGR of 34%. Max drawdown a reasonable 12%. You switch to paper trading and watch your strategy bleed out over the next two weeks.

If this sounds familiar, you're not doing anything wrong. Backtests lie by design — and paper trading in isolation doesn't fix the problem. Here's what's actually happening, and a better way to evaluate strategies before you put real capital on the line.

Problem 1: Survivorship Bias in Your Data

If you're testing against S&P 500 constituents, you're testing against today's winners. The companies that went bankrupt, got delisted, or dropped out of the index over your test period aren't in your dataset.

This matters more than people realize. A strategy that "buys the dip on large-caps" looks spectacular if you're only testing on companies that survived. In reality, buying dips on Lehman Brothers in 2008 was a one-way ticket to zero.

The fix: Use point-in-time data that includes delisted stocks, or at minimum acknowledge this bias when evaluating results. If your edge depends on survivorship-biased data, it's not a real edge.

Problem 2: Look-Ahead Bias

This one is sneaky. It happens when your strategy accidentally accesses future data during backtesting.

Classic examples:

Using adjusted closing prices (which get recalculated retroactively when splits or dividends happen)
Rebalancing at the exact open price of the next day (impossible in practice)
Using a moving average that's recalculated with data you wouldn't have had

# This looks fine but introduces look-ahead bias:
df['ma_200'] = df['close'].rolling(200).mean()
df['signal'] = df['close'] > df['ma_200']  # Fine

# This is look-ahead bias — you're shifting the signal:
df['signal'] = df['close'].shift(-1) > df['ma_200']  # BAD

The second version is using tomorrow's close to make today's decision. Your real portfolio can't do that.

The fix: Always check that your signal is based on data available at signal generation time. When in doubt, add an explicit .shift(1) to your price data before generating signals.

Problem 3: Transaction Cost Blindness

Backtests routinely ignore:

Commissions (even "zero commission" brokers have payment for order flow)
Slippage (you don't always fill at the price you wanted)
Market impact (larger orders move the price)
Spread (bid-ask spread on less liquid names)

A strategy that trades 50 times a month with a theoretical 0.5% edge can easily get eaten alive by 0.1% slippage per trade. Run the math:

gross_return = 0.005  # 0.5% per trade
slippage_per_trade = 0.001  # 0.1% slippage
num_trades = 50
net_return = (gross_return - slippage_per_trade) * num_trades
# 0.004 * 50 = 0.20 (20%) vs 0.005 * 50 = 0.25 (25%)
# That 5% difference is real money

The fix: Use realistic transaction cost assumptions. For Alpaca paper trading, simulate slippage by assuming fills 0.05–0.1% worse than the midpoint. This is conservative but forces your strategy to prove it has real edge.

Problem 4: Single-Path Testing

Most backtests test one path through history. But markets have many possible paths. The specific sequence of events from 2020-2023 — COVID crash, meme stock mania, rate hike cycle — was one realization of many possible worlds.

Your strategy might have crushed that specific path but would have failed in 60% of plausible alternative scenarios.

This is where tournament-style testing changes the picture. Instead of one backtest, you run dozens — varying:

Start dates (offset by weeks or months)
Market regimes (bull, bear, high vol, low vol)
Parameter ranges (walk-forward optimization)

If your strategy only looks good in the one path you happened to test, that's not a strategy — it's curve fitting.

How TradeSight Approaches This

I built TradeSight to address exactly these problems with paper trading evaluation.

The core idea is tournament mode: instead of running one strategy against one period, you run multiple strategies head-to-head across the same market conditions on Alpaca paper trading. The strategies compete for the same tickers on the same days, with identical transaction cost assumptions.

Key features:

Simultaneous multi-strategy comparison — no cherry-picking which strategy to test when
Consistent transaction cost modeling — same slippage assumptions across all strategies
Walk-forward validation — out-of-sample periods baked in, not bolted on
MC simulation — Monte Carlo over resampled return sequences to stress-test equity curves

A simple comparison run looks like this:

python tradesight.py --mode tournament \
  --strategies momentum_basic,mean_reversion_rsi,bollinger_squeeze \
  --tickers AAPL,MSFT,NVDA,GOOGL \
  --period 90d \
  --paper-account your_alpaca_key

The output tells you not just which strategy won, but why — which market conditions favored it, how it performed in drawdown periods, and whether the edge holds across parameter variations.

The Honest Backtest Checklist

Before trusting any backtest result:

[ ] Is your data survivorship-bias free?
[ ] Are you using adjusted close prices and accounting for it?
[ ] Have you verified no look-ahead bias in signal generation?
[ ] Are transaction costs modeled realistically (including slippage)?
[ ] Have you tested across multiple start dates, not just one?
[ ] Have you done out-of-sample validation on data the strategy never "saw"?
[ ] Does the strategy perform consistently across different market regimes?

If you can check all seven boxes, your backtest result means something. If you can't, treat it as a hypothesis — not a conclusion.

Paper Trading Is Still Useful — Just Not for Validation

Paper trading with Alpaca is great for testing execution — does your order routing work? Does your position sizing math hold up? Are there bugs in your live data feed handling?

It's not great for strategy validation because you're only seeing one more path through market history. Combine it with rigorous backtesting (with the above fixes) and tournament comparison, and you have something worth trusting.

The market doesn't care how good your backtest looks. It only cares what you do with real capital.

GitHub: https://github.com/rmbell09-lang/tradesight

"5 Python Libraries That Power My Self-Hosted Billing Monitor"

Ray — Mon, 30 Mar 2026 15:30:26 +0000

5 Python Libraries That Power My Self-Hosted Billing Monitor

When I started building BillingWatch, I had one goal: catch billing anomalies before they become customer support nightmares. A refund tsunami at 2 AM. A webhook that quietly stops firing. Subscriptions flipping to "canceled" for no obvious reason.

The commercial tools — Baremetrics, ChartMogul, Datadog — can do this, but they run $50–$400/month and you're trusting a third party with your entire billing data. I wanted something self-hosted, auditable, and free to run.

Here are the 5 Python libraries that made BillingWatch work.

1. `stripe` — The Foundation

pip install stripe

Stripe's official Python SDK is the backbone of the whole system. BillingWatch uses it for two things: pulling historical event data for backfill and verifying webhook signatures so we know events are actually from Stripe.

The signature verification piece is critical:

import stripe

def handle_webhook(payload: bytes, sig_header: str) -> dict:
    try:
        event = stripe.Webhook.construct_event(
            payload, sig_header, settings.STRIPE_WEBHOOK_SECRET
        )
        return event
    except stripe.error.SignatureVerificationError:
        raise ValueError("Invalid webhook signature")

Without this check, any bad actor could POST fake billing events to your endpoint. The construct_event call verifies the HMAC signature Stripe includes in every webhook request.

The SDK also handles pagination cleanly when backfilling historical charges:

events = stripe.Event.list(type="charge.failed", limit=100)
for event in stripe.auto_paging_iter(events):
    process_event(event)

2. `fastapi` — The API Layer

pip install fastapi uvicorn

FastAPI handles the webhook receiver, the REST API for the dashboard, and the admin endpoints. I chose it over Flask for three reasons: async support (webhooks can come in fast), automatic OpenAPI docs, and Pydantic validation that makes the event parsing bulletproof.

The webhook receiver is a single async endpoint:

from fastapi import FastAPI, Request, HTTPException
import stripe

app = FastAPI()

@app.post("/webhooks/stripe")
async def stripe_webhook(request: Request):
    payload = await request.body()
    sig_header = request.headers.get("stripe-signature")

    try:
        event = stripe.Webhook.construct_event(
            payload, sig_header, WEBHOOK_SECRET
        )
    except ValueError:
        raise HTTPException(status_code=400, detail="Invalid payload")

    await process_billing_event(event)
    return {"status": "ok"}

The async design matters because Stripe has a 30-second timeout on webhook delivery. If your handler is slow, Stripe retries — and then you're processing duplicates. FastAPI's async model keeps things fast enough that this hasn't been a problem.

3. `sqlalchemy` + `alembic` — Persistent Anomaly Storage

pip install sqlalchemy alembic

Every billing event gets persisted. SQLAlchemy handles the ORM layer, Alembic handles schema migrations. The core model is simple:

from sqlalchemy import Column, String, Float, DateTime, JSON
from database import Base

class BillingEvent(Base):
    __tablename__ = "billing_events"

    id = Column(String, primary_key=True)
    event_type = Column(String, index=True)
    amount = Column(Float)
    currency = Column(String)
    customer_id = Column(String, index=True)
    created_at = Column(DateTime)
    raw_data = Column(JSON)
    anomaly_score = Column(Float, default=0.0)
    flagged = Column(Boolean, default=False)

The anomaly_score field is populated by the detection logic — things like "this customer just triggered 5 failed charges in 10 minutes" or "refund amount exceeds original charge." The flagged column drives the dashboard alerts.

Alembic migrations mean schema changes don't break production deployments:

alembic revision --autogenerate -m "add anomaly score column"
alembic upgrade head

4. `apscheduler` — The Heartbeat

pip install apscheduler

BillingWatch doesn't just react to webhooks — it also runs periodic digest checks. Every hour, it scans for patterns that wouldn't be obvious from individual events: rolling refund rates, sudden drops in new subscriptions, failed charge clusters.

APScheduler makes this dead simple:

from apscheduler.schedulers.asyncio import AsyncIOScheduler

scheduler = AsyncIOScheduler()

@scheduler.scheduled_job("interval", hours=1)
async def hourly_digest():
    anomalies = await check_rolling_metrics()
    if anomalies:
        await send_alert_digest(anomalies)

scheduler.start()

The async scheduler runs inside the same FastAPI process — no Celery, no Redis, no separate worker. For a self-hosted tool running on a $5 VPS, that simplicity matters a lot.

5. `httpx` — Outbound Alerts

pip install httpx

When something trips an anomaly threshold, BillingWatch needs to tell you. I went with httpx over requests because it's async-native, which means alert delivery doesn't block the webhook handler.

The alert dispatcher is a small utility:

import httpx

async def send_webhook_alert(webhook_url: str, payload: dict):
    async with httpx.AsyncClient(timeout=10.0) as client:
        try:
            resp = await client.post(webhook_url, json=payload)
            resp.raise_for_status()
        except httpx.HTTPError as e:
            logger.error(f"Alert delivery failed: {e}")

This powers Slack notifications, Discord alerts, or any custom webhook endpoint. BillingWatch doesn't care where the alert goes — it just needs a URL.

Putting It Together

The full stack looks like this:

Stripe → Webhook → FastAPI receiver → SQLAlchemy storage
                                    → APScheduler digest checks
                                    → httpx alert dispatch

No containers required for local dev. Just:

git clone https://github.com/rmbell09-lang/billingwatch
cd billingwatch
pip install -r requirements.txt
cp .env.example .env  # add your STRIPE_WEBHOOK_SECRET
uvicorn main:app --reload

Why Self-Host?

The honest reason: I don't want Baremetrics or Datadog seeing every charge, refund, and subscription churn event from my business. That's the full picture of revenue health — and it belongs on infrastructure I control.

BillingWatch runs on a $6/month VPS. The only external dependency is Stripe itself.

If you're running a Stripe-based product and haven't set up anomaly monitoring, it's worth 30 minutes. The next billing anomaly you miss will cost more than that.

GitHub: https://github.com/rmbell09-lang/billingwatch

BillingWatch vs Datadog vs Baremetrics: What You Get for Free vs 0/mo for Billing Monitoring

Ray — Mon, 30 Mar 2026 09:30:45 +0000

BillingWatch vs Datadog vs Baremetrics: A Practical Comparison

As a developer running a SaaS application, keeping track of your customers' billing and revenue is crucial. While tools like Datadog and Baremetrics offer advanced features for billing monitoring, they come with a significant price tag. In this article, I'll compare these services with BillingWatch, an open-source platform that offers similar functionality at no cost.

Comparison Table

Feature	BillingWatch	Datadog	Baremetrics
Self-hosted	Yes	No	No
Stripe Integration	Excellent	Good	Good
Alerting	Yes	Yes	Yes
Custom Dashboards	Yes	Yes	Yes
Cost	Free	9/month	9/month

BillingWatch: A Self-Hosted Alternative

BillingWatch is a self-hosted billing monitoring platform built on top of Stripe's API. Its open-source nature allows for customization and modification to suit your specific needs. With BillingWatch, you can create custom dashboards, set up alerts, and integrate with your existing stack.

Setup Time

One of the main advantages of BillingWatch is its ease of setup. The platform comes with a simple deployment process that requires only a few minutes to get started. Clone the repository, configure your Stripe API keys, and you're good to go. No vendor lock-in, no monthly subscription creeping up on you.

Cost Comparison

While Datadog and Baremetrics offer advanced features for billing monitoring, their pricing model may not be suitable for every business — especially early-stage SaaS where 0/month matters. With BillingWatch, you get similar core functionality at zero recurring cost. The self-hosted nature also means your billing data never leaves your infrastructure.

When to Use Each

BillingWatch: You want self-hosted, full control, zero cost, and Stripe as your payment processor.
Datadog: You're already in the Datadog ecosystem and need billing metrics alongside APM/infra.
Baremetrics: You want SaaS analytics with MRR/churn reporting and don't want to self-host anything.

Conclusion

If you're running a SaaS application and want to monitor billing without paying for another SaaS tool, BillingWatch is worth a look. It's open source, self-hostable, and integrates directly with Stripe webhooks.

Check out the BillingWatch GitHub repository to get started.

Why I Switched from Interactive Brokers Paper Trading to Alpaca + TradeSight

Ray — Mon, 30 Mar 2026 09:29:28 +0000

Why I Switched from Interactive Brokers Paper Trading to Alpaca + TradeSight

As a Python developer and algo trader, I've spent countless hours setting up paper trading environments for testing my strategies. For years, I relied on Interactive Brokers (IB) for this purpose. However, after discovering Alpaca and TradeSight, I made the switch. In this article, I'll share my experience comparing IB paper trading with Alpaca + TradeSight, highlighting key differences in setup complexity, API quality, cost, data access, and speed.

My Experience with Interactive Brokers

I first started using IB's paper trading feature to test my trading ideas. The process was straightforward: create an account, fund it with fake money, and start trading. However, as I delved deeper into the world of algo trading, I began to encounter issues. The API documentation was extensive, but navigating the complexities of IB's API proved to be a challenge.

For instance, retrieving real-time market data required additional setup steps, including creating a separate account for each exchange and configuring custom APIs. Additionally, IB's API had limitations on the number of requests per minute, which forced me to implement rate limiting in my code. These obstacles consumed more time than I care to admit, taking away from the actual development process.

Enter Alpaca + TradeSight

That all changed when I discovered Alpaca and TradeSight. Alpaca provides a simple, Python-friendly API for accessing financial markets, with no account setup or funding requirements. TradeSight is an open-source platform for building custom trading dashboards and indicators, built on top of Alpaca's API.

The integration between Alpaca and TradeSight was seamless. With TradeSight's intuitive dashboard, I could easily access real-time market data, create custom indicators, and backtest my strategies without worrying about the underlying infrastructure. The API quality was significantly better than IB's; requests were handled with ease, and rate limiting was a thing of the past.

Cost Comparison

IB's paper trading environment can be cumbersome to set up, and their overall pricing model is complex. Alpaca, on the other hand, offers a free plan that includes generous API access, making it an attractive option for developers and algo traders who want to test their strategies without added overhead.

Data Access and Speed

One of the main reasons I switched from IB paper trading to Alpaca + TradeSight was data access. With TradeSight's custom indicators and real-time market data, I could focus on developing my algorithms rather than wrestling with APIs or waiting for delayed quotes. The speed at which I could test and refine my strategies improved significantly.

Conclusion

In conclusion, while IB paper trading has its advantages, the setup complexity and API friction eventually led me to try Alpaca + TradeSight. With Alpaca's Python-friendly API and TradeSight's open-source platform, I can now focus on developing my trading strategies without the hassle of infrastructure management.

If you're a fellow developer or algo trader facing similar challenges with IB paper trading, I encourage you to explore Alpaca and TradeSight for yourself. Check out the TradeSight GitHub repository for more information.

I Built a Stock Scanner with Python and RSI Signals — Here Is What I Learned

Ray — Mon, 30 Mar 2026 05:58:58 +0000

As a developer interested in finance, I have been experimenting with building tools to analyze stock markets using technical indicators. In this article, I will share my experience creating a simple stock scanner using Python that uses Relative Strength Index (RSI) signals.

What is RSI?

The RSI is a momentum indicator by J. Welles Wilder (1978). It measures recent price change magnitude to determine overbought (>70) or oversold (<30) conditions.

Fetching Stock Data with yfinance

import yfinance as yf

symbols = ["AAPL", "GOOG", "MSFT", "AMZN"]

data = []
for symbol in symbols:
    ticker = yf.Ticker(symbol)
    hist = ticker.history(period="1y")
    data.append(hist)

Calculating RSI

def rsi(data, window=14):
    delta = data["Close"].diff().dropna()
    u = delta.clip(lower=0)
    d = (-delta).clip(lower=0)
    rs = u.ewm(com=window-1, adjust=False).mean() / d.ewm(com=window-1, adjust=False).mean()
    return 100 - (100 / (1 + rs))

Generating Buy/Sell Signals

overbought_threshold = 70
oversold_threshold = 30

for i, symbol in enumerate(symbols):
    current_rsi = rsi(data[i]).iloc[-1]
    if current_rsi > overbought_threshold:
        print(f"{symbol}: SELL signal (RSI={current_rsi:.1f})")
    elif current_rsi < oversold_threshold:
        print(f"{symbol}: BUY signal (RSI={current_rsi:.1f})")
    else:
        print(f"{symbol}: HOLD (RSI={current_rsi:.1f})")

What I Learned

RSI alone is noisy — volume and trend confirmation is essential
Backtesting is mandatory — signals that look great on a chart often collapse under real conditions
Paper trade first — always validate with fake money before risking real capital

If you want to take this further, I built TradeSight — a self-hosted Python app that runs AI-powered strategy tournaments overnight and paper trades via Alpaca. No cloud subscription, everything on your machine.

Happy to answer questions in the comments!

Scaling a Self-Hosted Billing Monitor from 1 to 100 Tenants

Ray — Mon, 30 Mar 2026 03:27:15 +0000

When I built BillingWatch, I designed it for a single Stripe account. Then people started asking about multi-tenant support. Here's what the architecture looks like when you scale from 1 to 100 tenants.

The Core Multi-Tenancy Pattern

The simplest approach: row-level tenant isolation with a tenant_id on every table. BillingWatch uses FastAPI + SQLite (upgradeable to Postgres), with every query scoped to the requesting tenant:

from fastapi import FastAPI, Header, HTTPException
from sqlalchemy.orm import Session

app = FastAPI()

def get_tenant_id(x_tenant_id: str = Header(...)):
    if not x_tenant_id:
        raise HTTPException(status_code=401, detail="Missing tenant header")
    return x_tenant_id

@app.get("/anomalies")
def list_anomalies(tenant_id: str = Depends(get_tenant_id), db: Session = Depends(get_db)):
    return db.query(Anomaly).filter(Anomaly.tenant_id == tenant_id).all()

Every webhook endpoint, every query, every dashboard call is scoped this way. It's boring and it works.

Webhook Routing at Scale

The tricky part is routing Stripe webhooks when you have 100 different Stripe accounts. The clean solution: each tenant gets their own webhook endpoint with a unique path token:

@app.post("/webhook/{tenant_token}")
async def stripe_webhook(tenant_token: str, request: Request):
    tenant = db.query(Tenant).filter(Tenant.webhook_token == tenant_token).first()
    if not tenant:
        raise HTTPException(status_code=404)

    # Verify Stripe signature against THIS tenant's secret
    payload = await request.body()
    sig = request.headers.get("stripe-signature")
    try:
        event = stripe.Webhook.construct_event(payload, sig, tenant.webhook_secret)
    except stripe.error.SignatureVerificationError:
        raise HTTPException(status_code=400)

    process_event(event, tenant.id)
    return {"status": "ok"}

This means each tenant registers https://yourdomain.com/webhook/<unique-token> in their Stripe dashboard. Clean separation, no shared secrets.

Deduplication: Don't Process Twice

Stripe retries webhooks on failure. At 100 tenants you'll hit duplicate events. A simple idempotency table:

class ProcessedEvent(Base):
    __tablename__ = "processed_events"
    event_id = Column(String, primary_key=True)
    tenant_id = Column(String, nullable=False)
    processed_at = Column(DateTime, default=datetime.utcnow)

def process_event(event, tenant_id):
    existing = db.query(ProcessedEvent).filter_by(
        event_id=event.id, tenant_id=tenant_id
    ).first()
    if existing:
        return  # already processed

    # ... process the event ...

    db.add(ProcessedEvent(event_id=event.id, tenant_id=tenant_id))
    db.commit()

Add a composite index on (event_id, tenant_id) and this query is fast even at millions of rows.

Database Considerations

For 100 tenants with moderate webhook volume, SQLite holds up fine if you enable WAL mode:

@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
    cursor = dbapi_connection.cursor()
    cursor.execute("PRAGMA journal_mode=WAL")
    cursor.execute("PRAGMA synchronous=NORMAL")
    cursor.close()

For higher scale, the row-level isolation pattern migrates cleanly to Postgres — the application code doesn't change, just the connection string.

Rate Limiting Per Tenant

You don't want one tenant flooding your webhook processor. A simple in-memory rate limiter per tenant_id:

from collections import defaultdict
from time import time

request_counts = defaultdict(list)

def check_rate_limit(tenant_id: str, limit=100, window=60):
    now = time()
    request_counts[tenant_id] = [t for t in request_counts[tenant_id] if now - t < window]
    if len(request_counts[tenant_id]) >= limit:
        raise HTTPException(status_code=429, detail="Rate limit exceeded")
    request_counts[tenant_id].append(now)

What I'd Do Differently

Start with row-level isolation from day one — retrofitting is painful
Use unique webhook tokens immediately, not shared secrets
Add the deduplication table before you need it — much easier than adding later

The full BillingWatch source, including the multi-tenant webhook handling, is at github.com/rmbell09-lang/billingwatch.

Anything you'd handle differently at scale? I'm particularly curious about Postgres schema-per-tenant vs row-level at 1000+ tenants.

The Hidden Costs of Paper Trading: What 6 Weeks of Data Showed

Ray — Mon, 30 Mar 2026 03:26:33 +0000

As developers, we're often tempted to test our trading strategies using paper trading platforms. These tools allow us to simulate trades without risking any real money. But what happens when we start analyzing the data from these simulations? Do they accurately reflect what would happen in the real world?

I ran a 6-week experiment simulating trades across multiple strategies on various assets using TradeSight, my Python paper trading bot. The results were eye-opening.

Slippage: The Silent Killer

When executing trades, brokers incur slippage due to market conditions and order books. Paper trading platforms often assume perfect fill rates or don't account for this spread at all. In reality, even the best traders can expect some level of slippage.

Here's how I started accounting for it in Python:

import yfinance as yf

# Simulate slippage: assume 0.05% on each fill
def apply_slippage(price, direction='buy', slippage_pct=0.0005):
    if direction == 'buy':
        return price * (1 + slippage_pct)
    return price * (1 - slippage_pct)

data = yf.download('AAPL', period='1d')
raw_price = data['Close'].iloc[-1]
actual_buy = apply_slippage(raw_price, 'buy')
print(f'Raw: ${raw_price:.2f}, After Slippage: ${actual_buy:.2f}')

Over 6 weeks, slippage ate roughly 0.3% of total simulated returns — small per trade, huge compounded.

Fill Assumptions: The Unrealistic Benchmark

Paper platforms assume every trade fills at the exact price requested. Real brokers don't. I added a fill simulation layer to TradeSight that randomly rejects ~3% of orders and fills another 5% at a worse price:

import random

def simulate_fill(requested_price, fill_rate=0.97, slippage_range=0.001):
    if random.random() > fill_rate:
        return None  # rejected
    actual_fill = requested_price * (1 + random.uniform(0, slippage_range))
    return actual_fill

When I turned this on, my best backtest strategy dropped from 12% simulated returns to 9.4% — a 22% gap just from realistic fills.

Spread Modeling: The Hidden Cost

Most paper trading setups ignore bid-ask spread entirely. I calculated average spreads from 6 weeks of tick data:

import numpy as np

# Load tick data and calculate average spread per asset
spreads = {
    'AAPL': 0.03,   # percent
    'SPY':  0.01,
    'TSLA': 0.08,
}

avg_spread = np.mean(list(spreads.values()))
print(f'Average Spread Cost: {avg_spread:.2%}')

For high-frequency or short-holding strategies, a 0.04% average spread compounded across 50+ trades/week adds up fast.

What This Means for Strategy Development

After 6 weeks of realistic simulation, the takeaways were clear:

Never trust returns from platforms with perfect fill assumptions — add 10-20% haircut
Slippage matters most for volatile assets (TSLA, small caps)
Longer holding periods dilute these costs — overnight strategies survive better

TradeSight now models all three by default. If you want to see the full simulation code, it's on GitHub: github.com/rmbell09-lang/tradesight

Curious what hidden costs you've found in your own paper trading setups — drop a comment below.

7 Stripe Webhook Edge Cases That Break Billing (And How to Handle Them)

Ray — Mon, 30 Mar 2026 02:58:38 +0000

Introduction

As a developer building e-commerce platforms or subscription-based services, you're likely using Stripe for payment processing. However, Stripe webhooks can sometimes behave erratically, leading to billing issues.

In this article, we'll explore 7 common Stripe webhook edge cases that break billing and provide practical solutions to handle them. We'll use the BillingWatch framework as an example, which provides an open-source library for monitoring and handling Stripe webhooks.

Edge Case 1: Duplicate Events

When multiple events are triggered simultaneously (e.g., during a failed payment attempt), you may receive duplicate event notifications. To handle this, you can implement a simple deduplication mechanism using a database or cache layer:

import datetime as dt

# Store received event timestamps in a database or cache
event_timestamps = db.get_event_timestamps()

# Ignore duplicate events
if event.timestamp not in event_timestamps:
    # Process event normally

Edge Case 2: Out-of-Order Delivery

In some cases, Stripe webhooks may be delivered out of order, causing confusion and potential billing issues. To mitigate this, you can use a monotonic clock or a distributed locking mechanism to ensure events are processed in the correct order:

import time

# Use a monotonic clock to track event delivery timestamps
event_delivery_timestamps = []

# Ignore events delivered out of order
if event.delivery_timestamp <= max(event_delivery_timestamps):
    # Process event normally

Edge Case 3: Missing Metadata

Stripe webhooks may sometimes lack critical metadata, such as customer information or payment details. To handle this, you can implement a fallback mechanism using caching or database lookup:

# Cache customer metadata for later use
customer_metadata = cache.get_customer_metadata(event.customer_id)

# Fallback to cached metadata if necessary
if event.metadata is None:
    # Use cached metadata

Edge Case 4: Signature Failures

Stripe webhooks include a signature that verifies their authenticity. However, these signatures can sometimes fail due to network errors or other issues. To handle this, you can implement a retry mechanism with exponential backoff:

import time

# Retry failed signature verification after a short delay
if event.signature is None or not verify_event_signature(event):
    # Retry in 10 seconds
    time.sleep(10)

Edge Case 5: Duplicate Customer Information

Stripe webhooks may contain duplicate customer information, leading to incorrect billing. To handle this, you can implement a deduplication mechanism using a database or cache layer:

# Store received customer information in a database or cache
customer_info = db.get_customer_info()

# Ignore duplicate customer information
if event.customer_info not in customer_info:
    # Process event normally

Edge Case 6: Missing Payment Information

Stripe webhooks may sometimes lack critical payment information, such as card details or subscription status. To handle this, you can implement a fallback mechanism using caching or database lookup:

# Cache payment information for later use
payment_info = cache.get_payment_info(event.payment_id)

# Fallback to cached payment info if necessary
if event.payment_info is None:
    # Use cached payment info

Edge Case 7: Signature Expiration

Stripe webhooks include a signature that expires after a certain time. If this expiration occurs, you may need to handle the event differently. To do so, you can implement a retry mechanism with exponential backoff:

import time

# Retry expired signatures after a short delay
if event.signature is None or not verify_event_signature(event):
    # Retry in 10 seconds
    time.sleep(10)

Conclusion

Stripe webhooks can sometimes behave erratically, leading to billing issues. By implementing solutions for these common edge cases, you can ensure that your billing system remains accurate and reliable.

Remember to experiment with different deduplication mechanisms, caching strategies, and retry policies to optimize your event handling workflow. With the right approach, you can improve your billing accuracy and provide a better experience for your customers.

BillingWatch is open-source — self-hosted Stripe billing anomaly detector with multi-tenant support and webhook monitoring.

DEV Community: Ray

I Ran 10 Trading Strategies for 30 Days — Here Is What Actually Worked

I Ran 10 Trading Strategies for 30 Days — Here's What Actually Worked

The Setup

The Strategies

The Winners

The Middle of the Pack

The Failures

The Metrics That Actually Matter

What I'm Testing Next

Try It Yourself

Stop Paying for Monitoring: The Self-Hosted Stack for Indie SaaS Founders

Stop Paying for Monitoring: The Self-Hosted Stack for Indie SaaS Founders

The Real Cost Problem

The Self-Hosted Stack

Real Numbers

The BillingWatch Setup

The Broader Point

Self-Hosted Stripe Billing Monitor vs PagerDuty: Real Cost Breakdown

Self-Hosted Stripe Billing Monitor vs PagerDuty: Real Cost Breakdown

Setup Complexity

Alerting Features

Multi-Tenant Support

Webhook Monitoring

5 Things Paper Trading Taught Me That Backtesting Can't

5 Things Paper Trading Taught Me That Backtesting Can't

Slippage Reality

Emotional Discipline Simulation

Live Data Quirks vs Historical

Order Fill Variability

Strategy Confidence Calibration

"Why Your Paper Trading Backtests Are Lying to You (And How to Fix It)"

Why Your Paper Trading Backtests Are Lying to You (And How to Fix It)

Problem 1: Survivorship Bias in Your Data

Problem 2: Look-Ahead Bias

Problem 3: Transaction Cost Blindness

Problem 4: Single-Path Testing

How TradeSight Approaches This

The Honest Backtest Checklist

Paper Trading Is Still Useful — Just Not for Validation

"5 Python Libraries That Power My Self-Hosted Billing Monitor"

5 Python Libraries That Power My Self-Hosted Billing Monitor

1. stripe — The Foundation

2. fastapi — The API Layer

3. sqlalchemy + alembic — Persistent Anomaly Storage

4. apscheduler — The Heartbeat

5. httpx — Outbound Alerts

Putting It Together

Why Self-Host?

BillingWatch vs Datadog vs Baremetrics: What You Get for Free vs 0/mo for Billing Monitoring

BillingWatch vs Datadog vs Baremetrics: A Practical Comparison

Comparison Table

BillingWatch: A Self-Hosted Alternative

Setup Time

Cost Comparison

When to Use Each

Conclusion

Why I Switched from Interactive Brokers Paper Trading to Alpaca + TradeSight

Why I Switched from Interactive Brokers Paper Trading to Alpaca + TradeSight

My Experience with Interactive Brokers

Enter Alpaca + TradeSight

Cost Comparison

Data Access and Speed

Conclusion

I Built a Stock Scanner with Python and RSI Signals — Here Is What I Learned

What is RSI?

Fetching Stock Data with yfinance

Calculating RSI

Generating Buy/Sell Signals

What I Learned

Scaling a Self-Hosted Billing Monitor from 1 to 100 Tenants

The Core Multi-Tenancy Pattern

Webhook Routing at Scale

Deduplication: Don't Process Twice

Database Considerations

Rate Limiting Per Tenant

What I'd Do Differently

The Hidden Costs of Paper Trading: What 6 Weeks of Data Showed

Slippage: The Silent Killer

Fill Assumptions: The Unrealistic Benchmark

1. `stripe` — The Foundation

2. `fastapi` — The API Layer

3. `sqlalchemy` + `alembic` — Persistent Anomaly Storage

4. `apscheduler` — The Heartbeat

5. `httpx` — Outbound Alerts