Tenderly is a developer infrastructure platform for EVM-compatible blockchains that solves the fundamental debugging problem of smart contracts: when a transaction fails on-chain, the error message is often cryptic (a bare REVERT with no context), and reproducing the exact state that caused the failure is difficult. Tenderly provides three core capabilities that address this: transaction simulation (simulate a transaction against any historical chain state before sending to see if it will succeed or fail, and with what return values), transaction tracing (for any deployed transaction — success or failure — see a step-by-step execution trace with function calls, state changes, emitted events, and gas used per step), and real-time monitoring with alerts (define conditions on live contract behavior and receive instant notifications when triggered — e.g., “alert me if the protocol’s TVL drops by 20% in one block”). Tenderly supports 30+ EVM networks including Ethereum, Polygon, Arbitrum, Optimism, Base, and most EVM L2s. The Tenderly Virtual TestNets (successor to Tenderly Forks) allow development teams to spin up private mainnet forks accessible via standard RPC — all developers on a team share the same forked state for integration testing without any local node setup.
Core Features
The main features are described below.
Transaction Simulation
Before sending a token transfer:
→ Tenderly simulates the transaction
→ Shows: will it succeed? Return values? Gas estimate? Events emitted?
→ Catches: insufficient allowance, insufficient balance, wrong parameters
→ No gas spent — just simulation
API simulation:
POST https://api.tenderly.co/api/v1/account/{account}/project/{project}/simulate
{
“from”: “0xSenderAddress”,
“to”: “0xContractAddress”,
“data”: “0x…”,
“gas”: 500000,
“block_number”: “latest”
}
“`
Transaction Tracer
Any failed tx → Tenderly trace shows:
MyContract.deposit() called
→ USDC.transferFrom(sender, contract, 1000) — SUCCESS
→ MyContract._updateBalance(sender, 1000)
→ MyContract._checkLimit(1000) — REVERT
→ “Deposit exceeds daily limit” ← exact revert reason
+ State Changes: storage slot 0x12 changed from 800 → 1800
+ Gas used by each call: deposit(): 45,230 gas total
“`
Alerts & Monitoring
- Alert on: value thresholds, address activity, event emissions
- Channels: email, Slack, PagerDuty, webhooks
- Real-time: typical latency < 3s after block inclusion
Virtual TestNets
“`
tenderly.co → Create Virtual TestNet
→ Forks Ethereum mainnet at current block
→ Generates RPC URL: https://virtual.mainnet.rpc.tenderly.co/xxxxx
Team can:
- Share the same forked state
- Maintain persistent state across sessions
- Use Tenderly Explorer as block explorer for the fork
- No ETH needed: Tenderly auto-funds test wallets
“`
vs. Alternative Debugging Approaches
| Approach | Replay TX | Fork Mainnet | Team Sharing | Setup |
|---|---|---|---|---|
| Tenderly | Yes (UI+API) | Yes (Virtual TNs) | Yes | Minimal |
| Foundry Forge | Yes (cast run) | Yes (anvil –fork) | No (local only) | Install |
| Hardhat Network | Limited | Yes (–fork) | No | Install |
| Etherscan | Partial | No | N/A | None |
Related Terms
Sources
- “Tenderly Platform: Developer Infrastructure for EVM Debugging” — Tenderly (2020-2023). Platform documentation and architecture overview covering Tenderly’s core services — the simulation engine, transaction tracing infrastructure, real-time monitoring system, and the Virtual TestNets product — explaining how each service integrates into professional smart contract development workflows. = 0xVaultAddress; alert delivery: webhooks (most popular), email, Slack, PagerDuty, Telegram; latency: monitoring vs. in-block: Tenderly processes block within ~1-3s of inclusion; alert delivery: additional ~1-5s; acceptable for most monitoring use cases; not suitable for: MEV (needs mempool monitoring, different tool); pricing: free tier: 500 simulations/mo, 10 alerts; developer: $50/mo; team: $200/mo; enterprise: custom; conclusion: Tenderly has become the de facto professional debugging standard largely because of its UI — the transaction tracer is more approachable than Forge’s cast run; simulation API enables pre-flight checks in production dApp frontends.]
- “Transaction Simulation in Production dApps: Tenderly Simulation API” — Alchemy / DeFi UX Research (2023). Analysis of how production dApps use the Tenderly Simulation API for pre-flight checks — ensuring users see clear error messages before sending transactions, reducing failed transactions and improving DX (developer/user experience) in DeFi frontends.
- “Gas Profiling with Tenderly: Optimizing Smart Contract Gas Costs” — Gas Optimization Research / Tenderly (2022). Practical guide to using Tenderly’s gas profiler to identify gas inefficiencies in Solidity contracts — analyzing real transaction traces to find expensive function calls, storage operations, and loops, with before/after comparisons showing gas savings from targeted optimizations.
- “Tenderly Alerts: Real-Time Smart Contract Monitoring for DeFi Protocols” — Tenderly / Security Monitoring (2022-2023). Practical guide to setting up Tenderly alerts for DeFi protocol monitoring — covering alert trigger configuration, the difference between on-chain monitoring and mempool monitoring, incident response workflow integration, and real examples of alerts that detected exploits or anomalies before they became critical.
- “Tenderly Virtual TestNets vs. Anvil Forks: Selecting Your Fork Environment” — Alchemy / Developer Tooling Guide (2023). Comparison of Tenderly Virtual TestNets (cloud-hosted persistent forks) with Foundry’s Anvil local forking — examining team collaboration use cases, persistence requirements, RPC endpoint management, and which tool is appropriate for different stages of the development workflow.