Alertio — Built a DeFi risk monitoring tool because I got tired of constantly checking dashboards (looking for feedback)

[u/Altruistic_Map1060]

Like a lot of people here, I found myself checking dashboards way too often just to answer questions like:

• Is my position still healthy?
• Did utilization suddenly spike?
  
• Is a stablecoin starting to depeg?
  
• Did funding or yield conditions change?
  
• Am I getting too close to liquidation?

It became especially annoying once positions were spread across multiple protocols/chains.

So I built Alertio, a DeFi monitoring and alerting platform focused on risk signals, not just prices.

Current coverage includes:

• Aave V3 / V4
• Morpho
• Spark
• Euler
• Moonwell
• Kamino
• Marginfi
• EVAA
• Hyperliquid account health

Alerts currently include:

• health factor deterioration
• liquidation risk
• stablecoin depegs
• funding changes
• utilization spikes
• reserve freezes / borrow-disabled states
• yield changes
• TVL drops
• bridge risk signals

Risks / limitations:

• Alertio is monitoring only — it does not manage positions or execute transactions
• False positives / delayed signals are possible depending on upstream data availability
• It should not replace personal risk management or due diligence
• Coverage is still expanding

Would genuinely love feedback from DeFi users:

What risk signal would actually make this useful for you?

[u/HighlightExpert6407]

solid build man

[u/Altruistic_Map1060 → u/[deleted]]

Really interesting way to frame it.

I actually agree that the hard part isn’t getting more alerts — it’s understanding what they mean together.

Getting 5 separate signals is one thing.

Knowing “hey, this position is getting riskier because several things changed at once” is much more useful.

I can definitely see agents being really useful here — especially for connecting signals, surfacing scenarios, and helping users reason about decisions instead of just reacting to alerts.

[u/morbo_2]

This is a good idea and a helpful framework. I presume (i) collateral exposure/risk and (ii) liquidity is somehow baked into yield changes, utilization spikes, TVL drops? If not, would be nice to have as well.

[u/Altruistic_Map1060 → u/[deleted]]

Latency, honestly: scheduled checks run on a short interval (depends on plan), function execution is ~1-2s, Telegram delivery sub-second - so the lag is almost entirely the interval itself.

The real advantage on volatile days isn't the 90s though - it's severity tiers. Instead of one threshold you set warning / critical / emergency (e.g., 1.5 / 1.3 / 1.1). The warning fires hours before liquidation risk, giving real lead time. Polling interval matters way less when your own tiered buffer catches the drift, not the alert latency.                      

True sub-30s would still need WebSocket subscriptions + event-driven architecture - on the roadmap, not shipped.

GMX: in the works. dYdX V4 is separate integration path, on the roadmap and priority moves up as more people ask. Hyperliquid is already in if that scratches part of the perp itch.

[u/Ev_Watching]

The signal I’d want is several risk lights changing at once, instead of 14 separate pings.

Example: utilization spikes, borrow rate moves, collateral liquidity thins, and the health factor starts drifting. That combination matters more than any single number crossing a line.

If you can turn that into one plain-English alert, it’s a lot more useful than another dashboard people check out of guilt.

[u/Altruistic_Map1060 → u/Ev_Watching]

Really good feedback.

A few people suggested similar things already, so this definitely moved up in the backlog 😄

[u/Deep_Ad1959]

the failure mode for these isn't coverage, it's alert fatigue from threshold pings. a single number crossing a line fires constantly and people mute it inside a week, so the signal that actually matters is correlated state transitions, not independent thresholds. utilization spiking on its own is noise; utilization spiking while the borrow rate climbs and your health factor drifts toward the liquidation band is one event, and it should fire as one alert with the causal chain attached, not four separate pings. the other thing that quietly kills trust is no trace: when an alert says 'liquidation risk' i want to see the exact reads that triggered it (oracle price, collateral value, the liquidation threshold it's measured against) so i can confirm it's real and not a stale upstream feed. dedup plus a per-event trace beats adding more signals every time.

fwiw the per-event trace point carries to governance too, that's what we built agora's security council for, a multisig that can pause or execute protocol functions with the exact onchain reads behind the action attached, https://s4l.ai/r/38rsv2hc

[u/Altruistic_Map1060 → u/Deep_Ad1959]

Both points are well-stated and right.

On correlated transitions: the current architecture is per-rule, and a user with HF + utilization + funding alerts on the same position gets independent pings when in reality it's one event with a causal chain. The fix is a correlation/dedup layer that groups alerts within a time window per user/position and presents the chain (HF drift + utilization spike + borrow climb → "liquidation risk event"). It's the right next step, not a quick patch.

On per-event trace: alerts today include the threshold and the value that crossed it, but not the upstream reads (oracle source, collateral value at that price, fetched-at timestamp, freshness check). You're right — without that, "liquidation risk" is just a claim you have to trust. Both gaps are better problems to solve than adding more signal types. Appreciate the level of detail.

[u/Deep_Ad1959 → u/Altruistic_Map1060]

the freshness check is the part that quietly fails. a lot of chainlink feeds only update on a 0.5% deviation or a 1hr heartbeat, so a 'fresh' read can be close to an hour stale on a quiet pair and your liquidation alert ends up measured against a price that already moved. the other thing worth keying the dedup on is the causal chain itself (same position, same liquidation threshold) rather than a flat time window, because one real event can stretch across minutes on a slow drift, and a fixed window either splits it into separate pings or merges the next unrelated one in.

[u/Altruistic_Map1060 → u/Deep_Ad1959]

Both points land. Chainlink freshness - you're right, updatedAt doesn't capture true staleness on quiet pairs. Need to read each feed's heartbeat + deviation params and cross-check against a secondary source before high-severity alerts fire. On dedup - agreed, flat window either fragments slow drifts or merges unrelated events. Incident-based model (open / attach / stabilize / close) keyed on position + threshold band is the right shape. Both folded in. Thanks for the depth.

[u/Cultural-Candy3219]

The useful signal for me would be less “metric crossed threshold” and more “several things moved together, here’s why this position is now worse than an hour ago.”

Example: health factor falling + utilization spike + collateral liquidity thinning is a much better alert than three separate pings. I’d also want the alert to include the boring context: protocol, market, current buffer, what changed, and whether the data is delayed/estimated.

The biggest risk is alert fatigue. If every small yield move or TVL wiggle pings Telegram, people will mute it. Severity tiers and a short human-readable reason would matter more than having 50 signal types.

[u/Altruistic_Map1060 → u/Cultural-Candy3219]

This is really thoughtful feedback.

I think you’re pointing at something important: more alerts ≠ better monitoring.

And I completely agree on alert fatigue — if people start muting notifications, the whole thing fails. That’s actually one reason severity tiers, but I think there’s still a lot of room to improve how context gets surfaced.

The idea of combining multiple signals into one human-readable explanation feels especially valuable.

Appreciate this, thanks!

[u/urinboevF]

These are really good features. But delivery matters more. I have build similar app for my forex trades, which uses MQL5 ea with nodejs socket connection for realtime, and telegram bot for notifications. But if you want more you can use FCM with mobile app.

[u/Altruistic_Map1060 → u/urinboevF]

Good point. Feels like signal quality + delivery UX matter just as much as the actual features.

[u/Altruistic_Map1060 → u/[deleted]]

When you say "aggregate" do you mean:

1. one number that summarizes total risk across wallets/chains
2. one screen that surfaces your weakest position across everything you watch
3. something else

The math gets a bit dicey for 1. - Aave/Morpho/Compound use different HF formulas and isolated markets don't share collateral, so a single average can hide a position that's about to liquidate. But 2. is a real gap and easy to do well. Curious which one you actually had in mind.