TL;DR: I built a price monitoring bot for Ethereum tokens that runs on my phone and costs $0/month. Monitors any token, sends instant Telegram alerts, logs everything to Supabase. Here's what I learned about DeFi automation, databases, and building real systems under constraints.
The Problem
You're a trader. You watch 5 altcoins. Market moves 20% while you sleep.
You miss it.
Existing solutions suck:
- TradingView: $10-100/month
- Binance alerts: Lag, limited tokens
- Manual monitoring: Burnout guaranteed
What if you built your own?
That's this project.
Architecture Decisions (The Foundation)
Before coding, I made 8 key decisions:
1. Price Check Frequency: 15 Minutes
- Every 1-min check for 100 tokens = 144k API calls/day (too much)
- 15 min = 192 calls/day (well within free tier)
- Sufficient to catch real moves, not micro-movements
2. Data Source: CoinGecko + Alchemy
- CoinGecko: Free price feeds, no auth needed
- Alchemy: Setup for future on-chain reads (liquidity, swaps, etc.)
- Fallback strategy built in
3. Storage: Supabase PostgreSQL
Why not Firebase or local JSON?
- SQL = powerful queries later
- Managed PostgreSQL = no server ops
- Free tier: 500MB + generous API
- RLS (Row Level Security) for safety
4. Token Management: JSON Config
Simple, human-editable, version-controllable. Can add tokens without redeploying.
5. Triggers: Both % Changes + Price Targets
- % changes catch momentum (alert if ±5%, ±10%, ±25%)
- Price targets catch ranges (buy @ $X, sell @ $Y)
- Having both = flexibility
6. Alerts: Telegram
- Instant push notifications (can't miss)
- Works on any device
- Rich formatting support
- Free and reliable
7. Error Handling: Alert on Critical Failures
Don't fail silently. Don't spam every error. Alert when >50% of checks fail.
8. Deployment: Termux on Phone
- Zero server costs
- Always online (phone on charger)
- Can deploy and code from same device
Lesson: Spend 30 mins deciding architecture. Saves hours of rework.
The Tech Stack
Node.js - Event-driven runtime, Termux support
node-cron - Runs your function every 15 minutes without a server
cron.schedule('*/15 * * * *', async () => {
await runCheck();
});
CoinGecko API - Zero auth, instant price feeds
const response = await fetch(
`https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses=${address}&vs_currencies=usd`
);
Supabase - Managed PostgreSQL with instant backups
- Why PostgreSQL? SQL means flexible queries later
- Why managed? You're paying for not running ops
Telegram Bot API - Push notifications
- Simple HTTP calls
- Instant delivery
- Formatted messages
How It Works (Every 15 Minutes)
1. Scheduler wakes up
2. Load token config (JSON)
3. For each token:
→ Fetch current price from CoinGecko
→ Query last stored price from Supabase
→ Calculate % change
→ Check triggers (% change + targets)
→ If triggered → Send Telegram alert
→ Log to database
4. Wait 15 minutes
5. Repeat
Trigger Logic
Type 1: Percentage Changes
"percentageChanges": [5, 10, 25]
- Price moved 5%+ → Alert
- Useful for: Catching momentum, volatility spikes
Type 2: Price Targets
"priceTargets": [
{ "price": 5.0, "type": "sell" },
{ "price": 8.0, "type": "buy" }
]
- Price crossed $5 selling level → Alert
- Useful for: Range trading, DCA strategies, support/resistance
Example:
- Previous price: $4.50
- Current price: $5.10
- Buy target: $5.00
- Result: ✅ Alert "Crossed $5.00 buy level"
The Errors I Hit
Error 1: RLS Permissions
permission denied for table price_history
Fix: Grant anonymous API key permissions
GRANT SELECT, INSERT, UPDATE ON public.price_history TO anon;
GRANT USAGE, SELECT ON SEQUENCE public.price_history_id_seq TO anon;
Lesson: Security-first defaults are good, but require understanding.
Error 2: Telegram Connection Timeout
Problem: Telegram API wasn't responding during startup
Fix: Made Telegram optional
if (TELEGRAM_BOT_TOKEN && TELEGRAM_CHAT_ID) {
await sendPriceAlert(message);
} else {
console.log('📝 [Mock Alert]', message);
}
Lesson: External dependencies should fail gracefully.
Error 3: CoinGecko Rate Limiting
Error: HTTP 429 Too Many Requests
Fix: Respect rate limits. Added delays between calls.
Lesson: Test with real APIs under real constraints.
Performance After 24 Hours
✅ Price checks: 96 (every 15 min)
✅ Alerts triggered: 3
✅ Price snapshots logged: 96
✅ Errors: 0
✅ Memory used: 5-10 MB
✅ CPU during check: <5%
✅ CPU idle: 0%
✅ Termux stability: Perfect
This tells me: System is reliable, minimal resource usage, scales to many more tokens.
What I'd Do Differently
1. Start with E2E tests
I built everything before testing end-to-end. Caught permission errors late.
2. Mock external APIs during development
Calling CoinGecko 50 times during dev = wasted API calls
3. Use TypeScript
JavaScript is fast, but TypeScript catches type errors before runtime
4. Add logging levels
Current code logs everything equally. Need filtering (debug/info/error)
5. Document while building
Docs after = forgotten context. Docs while = fresh thinking
What's Next
Phase 2: Liquidation Detector
- Monitor collateral prices on Aave, Compound
- Alert when liquidation price approaches
- Rank by urgency
Phase 3: Arbitrage Spotter
- Compare prices across DEXs
- Detect profitable spreads
- Calculate slippage
Key Takeaways
1. Architecture Matters
30 mins of architecture decisions saved hours of rework.
2. Pick Managed Services
Supabase, Alchemy, CoinGecko, Telegram = all managed. I don't run anything.
3. Fail Gracefully
One error shouldn't break the whole system.
4. Data is Everything
Storing every price check means I can analyze later.
5. Deploy Early
Deploy to production ASAP. Production teaches you fast.
Code Structure
All modular and focused:
bot.js (100 lines) - Scheduler + orchestration
db.js (80 lines) - Database I/O
triggers.js (60 lines) - Price evaluation logic
notifications.js (50 lines) - Telegram sending
config.json (20 lines) - Token watchlist
schema.sql (40 lines) - Database setup
Total: ~350 lines of code. You can understand the entire system in 30 mins.
Is This Production-Ready?
For solo/small trading: Yes.
- Runs 24/7 on phone
- Zero downtime
- Costs $0/month
- Scales to ~50 tokens
For institutional: Not yet.
- No redundancy
- No disaster recovery
- No audit logs
For learning: Absolutely. This is the foundation.
Final Thought
The hardest part of building isn't coding. It's deciding what to build and why.
I spent 20% of time on architecture. That decision paid for itself 5x over.
Next time you build, do the same:
- Define the problem
- Lock architecture
- Build the skeleton
- Deploy early
- Iterate based on reality
Don't overthink. Build. Learn. Repeat.
Built by: Wavvy
Timeline: Sept 1, 2026 (1 day start-to-production)
Status: Live and monitoring UNI + AAVE
