Here is the normal workflow for making a change to a smart contract when two people are involved: one person describes what they want. The other person opens their IDE, makes the change, pushes it to a branch, opens a pull request, and waits for a review. The first person looks at a diff full of Solidity they cannot read and says “looks good” because what else are they going to say.
That loop can take days. Sometimes a full week if your developer is in a different timezone or mid-sprint on something else.
We built live collaboration because that loop is broken. And today it is live for all Builder and Enterprise plans.
What you actually see when someone else is editing
Open a contract in Doodledapp and you will notice a presence bar at the top of your canvas. It shows stacked avatars for every team member currently viewing the same contract. Click it and you get names, roles, and profile links.
But the real thing is the cursors.
Each collaborator gets a color-coded cursor that moves across the canvas in real time. You can see exactly where they are looking, what they are dragging, and which part of the contract they are focused on. It is the same concept as Google Docs, except instead of watching someone type a paragraph, you are watching them wire a Require node into a transfer function.
When someone selects a node to edit it, that node locks. A visual indicator shows who has it. If you try to edit the same node, you get a clear message telling you who is working on it. No silent overwrites, no merge conflicts, no “wait, who changed this?”
Every change propagates instantly. New nodes appear on your canvas the moment they are placed. Connections light up as they are drawn. If your co-founder adds an access control check while you are adjusting the token supply logic, you both see the full picture evolve in real time.
The problem this solves
Remote blockchain teams have a well-documented coordination problem. Without face-to-face interaction, misunderstandings compound. A founder describes a feature in a Slack message. The developer interprets it, builds something close but not quite right. A review cycle starts. Then another one.
30% of remote employees report difficulties coordinating across time zones. In smart contract development, that coordination cost is amplified because the stakes are higher. You are not debugging a UI glitch. You are making sure the logic that handles real value is correct before it becomes immutable.
Most development tools treat collaboration as a git problem. Branch, merge, resolve conflicts, repeat. That works fine when everyone on the team reads code fluently. It falls apart when the person who needs to approve a change cannot read the diff.
Visual collaboration changes the dynamic completely. When your contract is a canvas of connected nodes instead of a text file, everyone on the team can see what is happening. The founder can watch the developer add a check and understand it immediately. The developer can point to a node and say “this is what changes” instead of explaining a 40-line diff.
How it works from your side
You do not need to set up anything complicated. Here is the flow:
Your team is managed through the Teams page in Doodledapp. Invite members by email, assign permissions (who can edit contracts, who can use the AI assistant, who manages the team), and grant the team access to specific projects.
Once a team member opens a contract that you are already editing, the collaboration session starts automatically. No links to share, no “join” buttons, no lobby screens. You just see their cursor appear.
From there, everything is live. Node additions, connection changes, setting updates. It all syncs instantly. When you undo something, everyone sees the undo. When someone drags a group of nodes to reorganize the layout, you see them move.
If someone goes inactive for ten minutes, the system gracefully disconnects them to keep the session clean. They reconnect automatically the moment they interact again.
What you can build with it
A study on real-time collaborative programming found that working together on the same codebase in real time improves code quality and knowledge sharing. Fewer mistakes, faster problem-solving, better communication. Pair programming alone can boost productivity by up to 15%.
But in the visual builder, the benefits go further than traditional pair programming because the barrier to participation is lower. You do not need to read Solidity to contribute. Here are a few scenarios where live collaboration changes the game:
Founder + developer building together. The founder drags in the business logic nodes (fee percentages, supply caps, access rules) while the developer handles the technical wiring (overflow checks, reentrancy guards, event emissions). Both contribute directly. No spec document needed.
Two non-technical co-founders prototyping. Neither writes code, but both understand the product. They build the first version of their token contract together on a call, discussing each node as they place it. By the end of the session they have a working contract, not a requirements doc.
Remote team doing a live review. Instead of reading a pull request, the team opens the contract together. The person who made the changes walks through it visually, pointing at nodes. Questions get answered in context, not in comment threads.
Onboarding a new team member. Show them the contract by building something small together. They learn the product, the tool, and the team’s patterns all at once.
Who gets access
Live collaboration is available on Builder ($99/month) and Enterprise ($299/month) plans. The Enterprise plan supports up to 10 team members per team with granular permissions. Additional seats are available if your team grows.
The free plan does not include collaboration, but you can still share published contracts as read-only links for feedback and review.
Try it now
Invite your first team member from the Teams page, open a contract together, and see what it feels like to build on-chain logic without waiting for anyone’s commit. The cursor thing alone is worth it.