Price prediction for e-commerce products is, statistically speaking, a solved problem. The data exists. The models work. So why did we build PricePulse?

The Math Works

Predicting Amazon price movements is straightforward:

Historical patterns are reliable. Products follow seasonal trends, sales cycles, and inventory patterns.
Data is abundant. Keepa has 15+ years of hourly price data.
Models are simple. You don't need transformers—basic time series models (ARIMA, Prophet) work fine.

Here's a simplified version of our model:

from prophet import Prophet
import pandas as pd

# Historical price data from Keepa
df = pd.DataFrame({
  'ds': dates,  # Timestamps
  'y': prices   # Historical prices
})

# Fit Prophet model
model = Prophet(
  seasonality_mode='multiplicative',
  changepoint_prior_scale=0.5
)
model.fit(df)

# Predict next 72 hours
future = model.make_future_dataframe(periods=72, freq='H')
forecast = model.predict(future)

With this simple setup, we get 80-85% accuracy on predicting whether prices will drop in the next week.

The Real Problem

But here's the thing: people don't need price predictions. They need to know when to buy.

That's a different problem.

Timing ≠ Prediction

Knowing a product will hit $299 next Tuesday doesn't help if:

You're busy Tuesday and forget to check
The deal sells out in 2 hours
A better deal appears Thursday

What you actually want is a system that:

Watches the price 24/7
Calculates the optimal buy window
Alerts you exactly when to act

Our Approach: Buy Windows

Instead of showing users a price chart, we compute 72-hour buy windows:

interface BuyWindow {
  startTime: Date;      // When the window opens
  endTime: Date;        // When it closes
  confidence: number;   // 0-100
  predictedPrice: number;
  reasoning: string;    // Why now?
}

function computeBuyWindow(product: Product): BuyWindow {
  const forecast = predictPrices(product.history);
  const currentPrice = product.currentPrice;

  // Find local minimum in next 30 days
  const minPrice = Math.min(...forecast.slice(0, 720)); // 30 days hourly
  const minIndex = forecast.indexOf(minPrice);

  // Check if we're within 5% of predicted minimum
  const priceGap = (currentPrice - minPrice) / minPrice;

  if (priceGap <= 0.05) {
    return {
      startTime: new Date(),
      endTime: addHours(new Date(), 72),
      confidence: 85,
      predictedPrice: currentPrice,
      reasoning: "Price is within 5% of predicted 30-day low."
    };
  }

  // Otherwise wait for the predicted drop
  return {
    startTime: addHours(new Date(), minIndex),
    endTime: addHours(new Date(), minIndex + 72),
    confidence: 75,
    predictedPrice: minPrice,
    reasoning: `Predicted drop to $${minPrice} in ${minIndex} hours.`
  };
}

Why This Matters

Cognitive load is expensive. Checking 10 products daily for price drops is exhausting. We reduce that to zero until it's time to act.

Speed wins. Lightning deals sell out in minutes. Voice alerts (under 30s from price drop to phone call) beat email (hours) or push notifications (often ignored).

Personalization scales. Different users have different thresholds. "Deal Hunter" wants every 10% drop. "Patience Pro" waits for 30%+ drops. Same model, different strategies.

The Technology

Keepa API for historical prices
Prophet for time series forecasting
PostgreSQL with TimescaleDB for price history
Twilio for voice alerts
Vercel Cron for hourly price checks

Lessons Learned

Simple models win. We tried LSTM, XGBoost, even GPT-4 fine-tuning. Prophet beats them all on price/performance.
Freshness > Accuracy. A 75% accurate prediction that runs every hour beats a 90% accurate model that runs once a day.
UX is the moat. The prediction isn't special. The "call you when it's time to buy" experience is.

Price prediction is solved. Proactive price prediction is the product.

Try it: Autonomy PricePulse™