The Glossary
This glossary covers core terms and definitions of Momen, categorized by their function in the development lifecycle.
General & Lifecycle
Terms related to the platform ecosystem, distinguishing between Edit Time (building the app) and Runtime (using the app).
| Term | Description |
|---|---|
| Frontend (Client) | The part of the app that users interact with (UI). Runs in the browser or on the App (iOS/Android). |
| Backend (Server) | The server-side logic and database that power the app behind the scenes. |
| Project | Includes all resources, designs, data, actions and configurations. One project can build multiple distinct frontend applications sharing the same backend. |
| Editor | The workspace where you build your app. |
| User center | The workspace for project management, account settings, and billing. |
| Project details | The main workspace for project management, including upgrading plan, resources monitoring, and more. |
| Backend changes | Changes to the backend configuration, including data tables, APIs, actionflows, and permission system. |
| Frontend changes | Changes to the frontend configuration, including page/component’s design, data, and action changes. |
| Sync changes (Sync backend changes) | Pushes your backend changes in editor to the server to make them effective. Can be done separately or as part of the publish process. |
| Mirror | A real-time frontend preview tool for debugging and testing. Used during development to instantly preview frontend changes on browser without rebuilding. |
| Preview | Builds a pre-release version for testing. Generates a staging domain for testing your application. Requires a “Preview again” to see new changes. |
| Publish | Releases your application to production environment, making it publicly accessible to your real users. You can choose to publish frontend only, or publish both frontend and backend (sync backend changes) together. |
| Error collector | Displays errors and warnings created during Edit Time (e.g., type errors, missing required inputs). |
| Log service | The built-in viewer for backend and runtime logs. Used to inspect failed executions, compare timestamps, and trace requests by traceId. |
| traceId | A unique identifier attached to a request or backend execution. Useful for locating the exact log entry related to a failure. |
| AI Debugger | The in-editor AI assistant for troubleshooting. It can analyze screenshots, error messages, request data, and log evidence to suggest likely causes and fixes. |
| Multiple clients | Allows building multiple distinct applications (e.g., User App, Admin Web, Driver App) within a single project, all sharing the same backend. |
| Momen domain | The default domain provided by Momen (e.g., example.villa.momen.app) for each web application. Users access your published application via this URL. |
| Custom domain | Your own domain linked to the Momen app. |
| Basic / Pro Plan | Pricing plans billed per project. Each plan offers different levels of resources (CPU, memory, storage, etc.) and features. |
Data
Terms related to database modeling (tables, fields, relations), data types, runtime variables, and data binding mechanisms.
| Term | Description |
|---|---|
| Data model | The overall structure design of your database. |
| Database | The backend system where persistent data is stored and retrieved, including all tables, records, and relations. |
| Table | A collection of data entries (rows) sharing the same structure. |
| Field | Also known as “Column”. In the context of a table structure, it defines the type and name of a specific piece of data (e.g., name field of type Text). In the context of a record (row), it refers to the actual value stored in that column. |
| Record | A single entry in a table. Also known as “Row”. |
| Relation | Connections between tables (One-to-one, One-to-many, Many-to-many). |
| Data source | The origin of data, which can be a data table or a third-party API. |
| Data binding | Dynamic data connection. The mechanism to link data from any source (variables, action outputs, database) to any destination (component properties, action inputs, logic conditions), allowing dynamic values to be passed at runtime. |
| Variable | A temporary storage unit used to hold data values (e.g., text, numbers) that can change while the app is running. |
| Client variable | Global variables scoped to the current client session. Data stored in client’s memory that is accessible across all pages within the specific client instance (e.g., Browser, App). |
| Page variable | The variables that exist only within the lifecycle of a page. |
| Page parameter | The data accepted by the page via the URL or navigation stack to initialize its context (e.g., loading a specific product by ID). |
| Logged-in user | Context data of the currently authenticated user. |
| Query | Read-only operation. Retrieves data without modifying any state. Queries are idempotent (multiple executions produce the same result) and can be safely used as data sources for components (e.g., database SELECT, GET APIs). |
| Mutation | State-changing operation. Modifies data or system state (e.g., database INSERT/UPDATE/DELETE, POST/PUT/DELETE APIs, AI actions, Actionflows). Must be explicitly triggered as actions, not used as data sources. |
| Subscription | Real-time Listener. Unlike a Query (fetch once), a Subscription maintains an open connection to receive automatic updates whenever data changes. |
| Formula | Logic used to calculate values or convert data formats (e.g., calculating Total Price = Price * Quantity). |
| Pagination | Breaking large datasets into smaller chunks (pages) to optimize loading performance and user experience. |
| Load more | Fetch Next Page. In the context of pagination, an action that fetches and appends the next set of records to the bottom of a paginated list. |
| Data Bird’s-eye View | A visual map showing the dependencies and reference relationships among tables, APIs, actionflows, and variables. Used for better debugging and maintenance in complex applications. |
Design: Canvas & Components
Terms related to UI construction, component types, and view management.
| Term | Description |
|---|---|
| Page | An independent page within the app. Can receive page parameters and declare page data sources for components inside the page. |
| Page Path | The URL path that identifies a specific page, coming after the domain (e.g., in https://example.com/product/123, the page path is /product/123). |
| Page Title | The text displayed on the browser tab (e.g., Home Page, Product Details). |
| Component | The basic building blocks (e.g., Button, Text, Image). |
| Display | A category of components for outputting information (Text, Image, Button, etc.). |
| Input | A category of components for user data entry (Text Input, Switch, Data Selector, etc.). |
| Container | Type of Component: A box that wraps other components and determines their arrangement (Row/Column). Page is a special type of container that can accept parameters and declare data sources. |
| Position | The method of arranging components on a page or container. |
| Relative Position | All components within the same immediate parent stack one after another, like paragraphs in a document. If you move one, the others shift to make room or fill the gap. |
| Absolute Position | Positions a component to a precise spot inside its immediate parent. It ignores other items (also called siblings) within the same parent and doesn’t push them around. |
| Fixed Position | The component locks to the user’s browser window content display area (viewport). It stays at the exact location of the viewport even when the user scrolls down the page. |
| Custom Component | A user-defined component package. |
| Code Component | Code-based component. Components developed using custom code (React) to achieve specialized UI or functionality not available natively in Momen. |
| Focus Mode | Isolated Canvas. Opens a specific container component on a separate, dedicated canvas for focused editing, independent of the main page layout. |
| Edit State | Configuring specific visual styles for different interaction states of a component (e.g., Normal, Hover). |
| Page Overview | A viewing mode that tiles thumbnails of all pages. |
💡
For a complete list of components, please refer to the Component List.
Action: Interactions & Logic
Terms related to user actions, actionflows, and system capabilities.
| Term | Description |
|---|---|
| Action | A logic operation triggered by an event (e.g., on click, on load, on change, etc.). Can be configured on components, app loading, page loading, and more. |
| Actionflow | A visual workflow for orchestrating multi-step backend (server-side) logic. Can be triggered by frontend events, schedules (cron), database changes or webhooks. |
| Trigger | The event that starts an action (e.g., On click, On load, Schedule, Database Change, Webhook). |
| Scheduled Job (Frontend) | Logic executed automatically at set intervals configured on the page’s action. |
| Action Editor | An independent, expansive workspace (modal) designed for visually orchestrating complex frontend action flows. |
💡
For a complete list of available triggers and actions (e.g., Navigation, Payment, Sign in, Show Toast), please refer to the Frontend Trigger & Action List and Actionflow Triggers & Nodes.
Resources: Compute & Storage
Terms related to infrastructure, quotas, and billing.
| Term | Description |
|---|---|
| Computing resources | The computational power allocated for running your app’s logic, including all the following resources. |
| Server | The host environment for your backend services. CPU determines how fast logic executes and limits how many concurrent requests can be run. Memory (RAM) determines how much data can be processed in memory at once. Insufficient CPU causes request queuing and slower response times; insufficient memory causes requests to fail. |
| Shared(Free/Basic/Pro) server | Multi-tenant Environment. Computing resources are pooled among multiple users. Performance may fluctuate during peak platform usage due to resource contention with other users. |
| Dedicated instance | Single-tenant Environment. Your project runs on isolated computing resources not shared with other users. This provides consistent high performance, better security isolation, and higher concurrency limits (RPS). |
| Database storage | Storage space allocated for all data tables and indices. Includes user data, business records, and index files for faster queries. |
| Object storage | Storage space for all files (e.g., user-uploaded images, videos, documents). |
| Outbound data transfer | The volume of data sent from the server to the user’s device. Includes static assets (HTML pages, scripts, CSS), media (images, videos), and file downloads. |
| AI points | Credits consumed when using AI features, billed based on Token usage (For specific conversion rates, please refer to the AI Points Calculator in the editor). |
| Automated Actionflow Runs | Quota for backend workflows triggered by Systems (Scheduled jobs, Webhooks, database changes) rather than manual user interactions. This limit does not apply for any project on its dedicated instance. |
| Log Retention Period | The length of time that the Momen keeps your application logs before automatically deleting them. |
Last updated on