Tenderly DevNets: Faster smart contract development and testing on production data from 30+ networks. Start building! 🚀

Tutorials

Team up & Level up: DevNets for Faster Web3 Development

Improving team collaboration and efficiency can help you ensure code consistency and build a better product faster. Find out how to use Tenderly DevNets to support your team with knowledge-sharing, easier and faster debugging, and an in-depth understanding of transaction behavior.

Milica Lukic
Milica Lukic
Jul 6, 2023 · 5 min read

In this post

Team up & Level up: DevNets for Faster Web3 Development

Having a well-organized team that fosters collaboration can help you build an innovative Web3 product and bring more value to your users. But how do you ensure team cohesiveness in the decentralized Web3 world? How much time and effort do you invest in coordinating your team and piecing the resources you need together? And with most of your team scattered across the globe, how do you ensure consistency in your code? 

All of this can be difficult even if your team members are all in the same place. Luckily, transparency, collaboration, and knowledge sharing are embedded in the Web3 community. Teams worldwide work together toward the same goal – realizing the potential of blockchain technology and bringing it to a mainstream audience. 

So, how do you make this easier for everyone involved? Hint: start with a shared resource that facilitates team collaboration, boosts efficiency, and eliminates unnecessary overhead – Tenderly DevNets. 

How to use DevNets to improve team collaboration

Tenderly DevNets are a managed, zero-setup environment for smart contract development and testing. With DevNets, you can make team collaboration easier in a few ways. Let’s dive into each one. 

1. Ensure code consistency by using the same environment

With Tenderly DevNets, you and your team can quickly execute and test your smart contracts against both historical and real-time production data. You get everything you need already deployed to a DevNet, without the need for contract (re)deployments to public testnets. 

And since you all have access to the same development and testing environment, your team members don’t need to recreate the same conditions. This way, you can significantly speed up your internal processes and keep your team aligned. 

With DevNets, your entire team can:

  • Inspect the same smart contract executions, look into issues together, and ensure high code quality and consistency
  • Control your testing environments with custom RPC methods that allow you to top off your test tokens, modify environment states, change blocks, and manipulate other parameters. 
  • Automate the creation of your DevNet environments with reusable templates and fresh network states. 
Running the first DevNet

2. Enable comprehensive tx insights while still in development

Aside from exploring executed transactions using Tenderly’s Transaction Trace and Debugger, your team members can also inspect transaction executions during development. Examining transactions within DevNets can provide your team with valuable insights into the underlying smart contract logic. 

Inspecting a simulated transaction within a DevNet
Inspecting a simulated transaction within a DevNet

By simulating transaction executions within a DevNet environment, your team members can:

  • Preview transaction outcomes against production data while still in development.
  • Quickly experiment with their smart contracts in a safe, forgiving environment. 
  • Play around with different transaction parameters and see what happens.
  • Try out different bug fixes and validate their solutions prior to deploying them. 

As poolpitako, a software engineer at Yearn Finance, explains:

You need to start learning how to read Tenderly before being able to read Etherscan. If a transaction hits Etherscan, that means that it's already too late and it's in prod, already executed, or minted. I think the best entry point is there, seeing a simulation of a multisig transaction, seeing what happens, trying to understand it, and playing with the transaction.” 

3. Share individual transactions and entire runs on DevNets

Another simple way to keep everyone on the same page is to share transactions that you simulate within your DevNet environments. And in addition to individual transactions, you can also share entire DevNet runs.

Sharing a DevNet development and testing environment publicly
Sharing a DevNet development and testing environment publicly

After running simulated transactions to test state-dependent scenarios, you can click the Share button and allow public access to your simulated transactions. This will generate a URL that you can share with your team and external collaborators.

A publicly shared Tenderly DevNet
A publicly shared Tenderly DevNet

This way, anyone on your team who doesn’t have a Tenderly account, or external collaborators, can explore all the simulated transactions under the same conditions. Plus, they can jump into Debugger to examine potential issues and continue experimenting with the code. 

💡

You can also use Tenderly Sandbox as an in-browser Fork environment for quick example-sharing. Tenderly Sandbox is a prototyping environment that allows you to experiment and execute your smart contracts instantly.

Spinning up a Sandbox runs it against an individual Tenderly Fork, so you and your team get the production data for more than 30 networks. And you can also quickly access all other Tenderly features since Sandbox is fully integrated with Tenderly’s debugging toolkit.

4. Jump into Debugger and guide your team with annotation and prioritization

When it comes to failed transactions, you and your team have immediate access to Tenderly Debugger, where you can inspect transaction execution in detail. You can use DevNets together with Debugger to: 

  • Inspect transactions trace by trace.
  • Explore state changes and emitted events.
  • See which contracts are involved in a transaction.
  • See how much gas transactions spend by a function call.
  • Evaluate complex expressions in a human-readable format. 

Plus, you can also use Debugger’s annotation and prioritization functionality to prioritize and comment on the exact lines of code with in-depth explanations. 

Commenting and prioritizing lines of code in Tenderly Debugger
Commenting and prioritizing lines of code in Tenderly Debugger

And what about stressful and urgent situations that require a quick and coordinated debugging response?

💡

The annotation and prioritization functionality can help you keep your team organized and focused in time-sensitive war room situations. If a hack or exploit happens, you can guide them by prioritizing the most suspicious lines of code for inspection.

And by leaving comments, you can also provide directions for removing vulnerabilities so you can quickly resolve the underlying cause of the issue.

Ensure team collaboration and contribute to Web3 innovation

Supporting knowledge-sharing and transparency across Web3 starts with your team. By encouraging your team members to collaborate, share knowledge, and provide feedback, you can not only build a cohesive team and a strong product but also support such practices in Web3 development. 

And with the full-stack Tenderly infrastructure, you get a partner to support you as your team grows. With everything in one place from development to production, you can improve your teams’ development flows and facilitate their collaboration. So, start using Tenderly DevNets and empower your team to build innovative Web3 solutions.

Use Tenderly DevNets to build, test, and debug smart contracts against production data of 30+ EVM networks. Get an unlimited faucet, reusable YAML templates, and built-in debugging tools to deploy on-chain faster.

Start building with DevNets!