The Wasm-based action builder is a new feature from Betty Blocks that brings the flexibility of high-code into the world of visual, low-code development. It lets developers write advanced logic in any language that compiles to WebAssembly (Wasm), such as Rust, C#, or Python, and then reuse that logic as drag-and-drop components within Betty Blocks.
This means teams no longer have to choose between full control (high-code) and speed (low-code). With the Wasm-based action builder, you get both.
High-code meets low-code
Traditionally, high-code and low-code have existed in separate silos. High-code offers total flexibility and control, but it comes with complexity and a reliance on scarce expert developers. Low-code is faster and more accessible, but often limited in how much it can be customized.
The Wasm-based action builder bridges this gap, allowing developers to:
- Write logic-heavy functions in their preferred programming language
- Compile them into Wasm
- Import them into Betty Blocks
- Let low-code builders configure and reuse them visually in workflows and applications
In other words, a high-code developer builds the core functionality once, and then low-code developers can use it many times without needing to touch the code.
Who is it for?
The Wasm-based action builder empowers two key personas in Betty Blocks:
- Low-code developers (the coders) – who work with APIs, set up remote models, and occasionally write code. They benefit from reusing Wasm logic without having to reimplement it
- Business technologists (the builders) – who configure apps visually. They can now use advanced logic components created by developers without needing to write a single line of code
Most low-code platforms come with limitations: you’re locked into their tech stack, their language, and their runtime. But with the Wasm builder, business logic is written in WebAssembly — a widely supported, open standard.
This means:
- You’re not tied to one language or one platform
- You can reuse logic elsewhere if needed
- Your team stays in control of your architecture
It’s a low-code platform that doesn’t force you into a proprietary box.
Wasm builder workflow
Using the Wasm-based action builder is straightforward. To get started, go to the Actions section and select Create new action > Wasm action. Give your action a name and description, and define if you want your action to be private (accessible to a certain role) or public (open for everyone to execute).
The Wasm-based action builder has three main areas:
- Wasm steps menu (1) on the left
- Choose default steps like Create record or Condition
- Add and use your own custom Wasm steps
- Builder canvas (2) in the center
- Design the full logic and flow of your action
- Drag and drop steps to build your action
- Options menu (3) in the top-right
- Access action settings (name, permissions, scheduling)
- Run tests
- Download the uploaded Wasm file
Add a custom Wasm step
Inside the action builder, you’ll see any existing Wasm steps. To add a new one, click + Add custom Wasm step.
In the form that appears, you'll see the steps you are to complete in order to add a new Wasm action step (1).
Upload your .wasm file using the browser in the File section (2), and select a category for this step from the list (3).
Because this Wasm step will be published in the Block Store, first choose a clear name and write a short description for the Wasm action step block before moving on to Configure steps.
Configure your Wasm components
In the following Configure tab, you view all inner components of your Wasm custom step. Since our file aimed to calculate values, our components here are four operations - add, divide, multiply and subtract.
Customize each component by giving it a clear name and description, and by adjusting its icon and color so it’s easy to recognize and reuse later. Press Review when you're done here.
Finally, review your work and click Save steps. If unsure, you can get back by clicking Configure steps or just cancel your configuration.
Wasm-based action builder menu
Just as in regular Betty's Actions menu, you can find action's options in the top right corner of the builder.
-
Settings: Update the action’s name and description, manage its permissions, configure its execution schedule, or delete the action entirely
-
Test run: Log and debug your Wasm action using regular in-platform testing or GraphQL Playground
-
Download: Download the currently used .wasm file to your device
Beyond updating the action’s name and description, the Settings menu also includes a Permissions tab, where you define which authentication profiles and application roles are allowed to execute the action.
Find more about scheduled actions in Creating a scheduled action.
Using Wasm action steps
Once created, your Wasm step will appear in the action builder menu and can be dragged into the canvas.
Let's take a simple use case as an example:
Calculate a final order total based on quantity, unit price and discount using Wasm-based calculation steps.
1. Add input variables to the Start step:
-
unitPrice (number) — e.g. 25
-
quantity (number) — e.g. 4
-
discount (number) — e.g. 10
2. Add Multiply step to calculate subtotal:
-
subtotal = unitPrice × quantity
3. Use Subtract step to apply a discount:
-
finalTotal = subtotal − discount
4. Lastly, you can add finalTotal variable as an output to Finish step:
Practical use cases
1. Complex logic made modular and reusable
Organizations often rely on custom logic such as pricing calculations, validation rules, or scoring models implemented in high-code environments. This logic can be difficult to reuse or maintain, especially when only a few developers understand it. With the Wasm-based action builder, this logic can be packaged into reusable action steps that integrate directly into visual workflows, making it easier to configure, document, and reuse across applications.
-
Example: calculation logic maintained in Excel can be translated into code, compiled into a Wasm module, and added as one or more Wasm action steps. You can encapsulate the entire calculation in a single step, or split it into smaller steps such as add, subtract, multiply, and divide. This allows you to choose between a fully encapsulated function or a more transparent, step-by-step workflow.
2. Fast collaboration across teams
Instead of having a single developer bottlenecked with high-code tasks, the Wasm-based action builder allows teams to collaborate. High-coders write core functionality. Low-coders and business technologists use it in apps, pages, and workflows, speeding up delivery.
3. Gradually modernize legacy systems
Legacy systems often contain critical business logic but are difficult to extend or integrate with modern applications. Instead of rebuilding everything, teams can extract specific logic from legacy systems, convert it into WebAssembly, and reuse it as Wasm action steps.
-
Example: a legacy pricing or validation function can be converted into a Wasm action step and used in new workflows. This allows teams to preserve proven logic while building modern applications around it, supporting gradual modernization without disrupting existing systems.
4. Convert external APIs into reusable action steps
Applications often integrate with external APIs that provide multiple endpoints for different operations. Instead of configuring separate HTTP steps for each endpoint, these interactions can be encapsulated into reusable Wasm action steps based on the API specification.
-
Example: endpoints such as Get posts, Create post, or Update post can each become dedicated Wasm action steps. These steps handle request and response logic internally, allowing builders to use external integrations as simple, reusable building blocks without managing low-level API details.