---
title: "Core Concepts · RUAL Documentation"
description: "The core concepts behind RUAL blueprints, blocks, storage and execution."
canonical: https://docs.rual.nl/getting-started/core-concepts
language: en
---

# Core Concepts

The key ideas behind RUAL. Blueprints, blocks, flows, storage, and deployment.

### What is RUAL?

RUAL is a no-code platform for building ERP/CRM systems, apps, and websites. You build all backend logic by placing blocks on a visual canvas, there is no custom backend code. The frontend can be built with blocks too, or with [custom React components](https://docs.rual.nl/interfaces/components) for more advanced use cases.

You manage your system in [RUAL Studio](https://docs.rual.nl/interfaces/rual-studio), the web application at [rual.at](https://rual.at). From there you manage blueprints, traffic, queue, deployment, translations, templates, and base settings for your cluster.

### Blueprints

A blueprint is a large canvas where you design workflows. You place blocks on it and connect them to create flows. Each blueprint is typically dedicated to a specific component: a page, modal, API, or a set of functions, similar to assigning a single class to a file in traditional coding.

Multiple users can work on the same blueprint at the same time. Team members can add comments, group blocks with titles, and copy blocks between blueprints. RUAL logs all blueprint modifications automatically, like git commits but with real-time collaboration.

Since [version 13.0.7](https://docs.rual.nl/core-versions/130007), blueprints have separate development and production modes. Saving does not deploy to production, you must explicitly deploy through the [deployment](https://docs.rual.nl/deployment/how-to-deploy) menu.

### Blocks

Blocks are the building units of every flow. There are over 1000 available, from array and date operations to HTTP requests and Discord integrations. Each block has input pins (in-pins) and output pins (out-pins) that define what data goes in and what comes out.

#### Pin Types

Pins are types, you can only connect pins of compatible types. The most common ones:

- `flow`: controls the execution order between blocks, determining *when* a block runs.

- `value`. A string value, such as a name, email, or identifier.

- `object`. A JSON object with key-value pairs.

### Flows

A flow is a group of connected blocks within a blueprint. Each flow has a starting block that determines its type and purpose. A single blueprint can contain multiple flows of different types.

#### Flow Types

The following flow types exist in RUAL, each starting with a specific block:

| Flow Type | Starting Block | Purpose |
| --- | --- | --- |
| **Page** | [`state_page`](https://docs.rual.nl/block-types/state%20ui/state_page) | Builds a user-facing page with UI components. Pages are accessible via URLs and can be public or restricted with [scopes](https://docs.rual.nl/blueprints/remote-access-control). |
| **Function** | [`trigger_custom_function`](https://docs.rual.nl/block-types/globals%2Cfunction%20execution/trigger_custom_function) | Creates a reusable function that can be called from other flows or blueprints. Functions are private by default. |
| **API** | `on_startup_register_uri_{method}` | Registers an API endpoint (GET, POST, PUT, PATCH, DELETE, or file upload) that can be called by external services or your frontend. |
| **Modal** | [`state_flow_modal`](https://docs.rual.nl/block-types/state%20ui/state_flow_modal) | Creates a pop-up modal that can be shown on a page. |
| **Storage Event** | [`storage_event`](https://docs.rual.nl/block-types/globals%2Cstorage/storage_event) | Executes when a document is created, updated, or removed in a specific storage. |
| **Repeating Event** | [`schedule_repeating_event`](https://docs.rual.nl/block-types/events/schedule_repeating_event) | Executes at a recurring interval, similar to `setInterval()` or `crontab`. |

### How Flows Work Together

In a typical app, a Page flow renders a form where users input data. When the user submits, a Function validates the input and creates a document in storage. A Storage Event picks up that write and sends a confirmation email in the background. An API endpoint lets external services query the same data, and a Repeating Event runs every hour to generate statistics and cache them in Redis.

Functions can be called from any flow type using the [`function_custom_execute`](https://docs.rual.nl/block-types/globals%2Cfunction%20execution/function_custom_execute) block. Public functions can be called across blueprints, while private functions are only accessible within their own blueprint.

### Storage

RUAL includes a built-in, enterprise-scale storage system with full-text search. Storage is JSON-based and schema-less. You don't need to predefine structures. It does not support relationships between entities, so include all necessary data within each document (denormalization).

Documents are updated using mutations, a transaction-based system that processes updates sequentially. This makes counters and array operations safe to use without race conditions.

### Activation and Deployment

Before any pages, APIs, modals, or events in a blueprint become active, you need to activate the blueprint using the `Activate` button in the top bar. All elements are inactive by default.

Since [version 13.0.7](https://docs.rual.nl/core-versions/130007), there is a clear split between development and production. Saving keeps changes in development mode. To make them available to users, you need to [deploy](https://docs.rual.nl/deployment/how-to-deploy) the blueprint to production.

### Next Steps

### Frequently asked

**What is the difference between a blueprint and a block in RUAL?**

A blueprint is the canvas that holds one piece of logic, such as a page, an API endpoint or a scheduled job. A block is a single step inside it. You build a flow by connecting blocks on the blueprint.

**What is the difference between activating and deploying in RUAL?**

Activating makes the saved version of a blueprint respond in the development view. Deploying publishes it to production. They are separate steps, so you can test a change before your users see it.