Beyond the Visual Editor: A Developer's Guide to Unlocking Full Control with Momen

Momen's development team has always held the view that, regardless of code or no-code, developers always need control over their product. This developer-first mindset is embedded in Momen's architecture, and has greatly influenced the product choices we made, and will continue to shape how we think about our product.

The No-Code Ceiling and the Pro-Code Escape Hatch

As professional developers, we know that the appeal of no-code platforms is often tempered by a significant concern: the "no-code ceiling". These platforms promise incredible initial velocity, allowing for the rapid creation of prototypes and MVPs. However, this speed can come at the cost of control, leading to a point where custom logic, bespoke user interfaces, or deep, non-standard integrations become prohibitively difficult or impossible. This is often also known as the dreaded "vendor lock-in", forcing teams into complex workarounds or, in the worst cases, a complete and costly rebuild on a traditional code stack.

At Momen, we believe we ought to create a platform that offers the ability to "Collaborate with Code" and "Complete Visibility", ensuring developers can build complex, scalable applications without ever hitting a ceiling.

The Universal Data Layer: Seamless Integration with a Self-Documenting GraphQL API

The single most important architectural decision that underpins Momen's power and flexibility for developers is its GraphQL-first foundation. This is not an optional feature or an afterthought. It is the core of the platform's data layer, as all backend requests use GraphQL (with the exception of webhooks). This choice provides a universal, intelligent, and highly efficient interface for all data interactions, enabling the advanced capabilities of the other control features.

The structured nature of GraphQL is what makes the Log Service so detailed and queryable. The query function available to custom React Components is a GraphQL client, allowing them to efficiently fetch precisely the data they need. The ability to embed complex GraphQL queries within server-side JavaScript gives developers unparalleled power for data manipulation. In essence, in the Momen world, GraphQL is the foundation upon which we built for visibility and the ability to collaborate with code.

Documentation That Never Lies

One of the most persistent frustrations for developers is out-of-date API documentation. GraphQL solves this problem by being inherently self-documenting. The GraphQL schema—a strongly typed definition of all available data, queries, and mutations—serves as a live, machine-readable contract that is always accurate.

Developers can use interactive tools like GraphiQL to explore the entire API, discover available fields, and build queries with auto-completion and real-time validation. This fundamentally changes the developer onboarding and collaboration workflow. A new team member can be pointed to the API endpoint and immediately understand its full capabilities without reading static documents. When a data model is changed in Momen's visual editor, the schema updates instantly, making the change discoverable by the entire team. This creates a low-friction, agile development process that directly supports Momen's promise of "Rapid Iteration" and effective "Team Collaboration".

Momen as a Headless Backend (BaaS)

The ultimate expression of control and flexibility is the ability to use Momen's powerful backend independently of its UI builder. Because Momen exposes a public, standards-compliant GraphQL API, it can function as a complete Backend-as-a-Service (BaaS) for any application. This means developers are never locked into Momen's frontend tools and have the freedom to:

• Build a native iOS or Android app that uses Momen for its entire backend, including data storage, user authentication, and business logic.

• Develop a web application using a different frontend framework like Vue.js or Svelte, while leveraging Momen for its scalable backend infrastructure.

• Integrate Momen as a microservice within a larger corporate architecture, where other systems can call its GraphQL API.

This capability directly refutes the notion of vendor lock-in and positions Momen as a powerful, flexible, and scalable backend that can be consumed by any client, anywhere.

Server-Side Superpowers: Injecting Custom JavaScript Logic into Actionflow

Momen's Actionflow is a powerful visual tool for building server-side workflows and automations. While its collection of built-in nodes can handle a wide array of tasks, there are scenarios where visual logic reaches its limit. For proprietary business algorithms, complex data transformations, or integrations with systems that lack a modern API, developers need the ability to write code. Momen provides this capability through the

"Custom Code" node, which allows for the injection of arbitrary JavaScript directly into a server-side Actionflow.

This feature almost turns Momen into an integrated, lightweight alternative to standalone Function-as-a-Service (FaaS) platforms like AWS Lambda or Google Cloud Functions for a wide range of use cases. Developers can write, deploy, and trigger server-side code entirely within the Momen ecosystem, avoiding the operational overhead and context-switching required to manage separate cloud infrastructure.

Current support is limited to V8 environments, no NodeJs support yet.

The context Bridge: Interfacing with the Momen Environment

Custom JavaScript code within an Actionflow does not execute in isolation. It is a first-class citizen of the workflow, interacting with other nodes and the broader Momen environment through a global context object. This object serves as a bridge, enabling seamless data flow:

• Getting Inputs: To access data passed in by previous nodes or the Actionflow's initial trigger, developers use the function context.getArg("input_parameter_name");.

• Returning Outputs: To pass the results of the custom logic to subsequent nodes, developers use context.setReturn("output_name", result_variable);.

• Manipulating Backend: To access data from the project's database, run other actionflows, invoke third-party APIs, developers use context.runGql("operationName", query, variables, { role });.

For example, a simple yet practical use case from the documentation involves masking a phone number. The Actionflow receives a full phone number as an input, a "Custom Code" node uses context.getArg('phone_number') to retrieve it, performs a string manipulation with JavaScript, and then uses context.setReturn('result_phone', result) to make the masked number available to the rest of the flow.

Actionflow as a Programmable, Serverless Backend

The "Custom Code" node, combined with Actionflow's other features, creates a robust, programmable, serverless environment. Developers can orchestrate complex sequences that mix visual configuration with custom code, including database operations, external API calls, AI agent execution, and permission management. This is supported by several powerful platform capabilities:

• Execution Modes: Developers can choose Synchronous execution for tasks that need strong consistency or Asynchronous for long-running background jobs that should not block the main thread.

• Transactional Integrity: Critically, for synchronous flows, Momen guarantees that if any node fails—including a custom code block—All data changes to the database will be rolled back. This provides the atomic, all-or-nothing guarantee required for building reliable transactional logic, such as financial transfers or multi-step order processing. This is a feature that is missing in almost all current no-code solutions in the market.

• Versatile Triggers: Workflows can be initiated by frontend events, scheduled via Cron expressions, triggered by database changes, or invoked by external systems through webhooks.

• Embedded GraphQL: For ultimate data manipulation power, a code node can contain raw GraphQL queries, enabling arbitrarily complex data manipulation, such as batch operations, directly on the server.

Higher plan tiers have higher limits on number of automated executions. In addition, for projects on single-tenant servers, Momen entirely removes the timeout limit on Actionflow execution and the limit on the number of automated executions, making it suitable for heavy-duty data processing.

Infinite Frontend Flexibility: Building Bespoke UIs with Custom React Components

While Momen provides a rich library of pre-built UI elements, it recognizes that true product differentiation often lies in a unique and highly polished user experience. For developers who need to move beyond standard widgets, Momen offers Code Components, providing an escape hatch to infinite frontend flexibility by allowing the creation and integration of custom React components written in TypeScript. This capability is the ultimate answer to UI limitations, empowering developers to build anything from data-driven charts and advanced animations to interactive maps and proprietary design systems.

A Professional and Familiar Workflow

Momen deeply respects established developer practices by integrating the Code Component workflow seamlessly with standard tools and command-line habits. Instead of trapping developers in a walled garden, it provides a professional and familiar development loop:

1. Setup: Developers begin by installing the Momen CLI.

2. Initialization: The command momen create project_name scaffolds a complete React and TypeScript project, including a template component, ready for development in any IDE like VS Code or Cursor.

3. Local Development: Running npm run dev starts a local development server for isolated component building and testing, exactly as one would in any standard React project.

4. Live Preview: By executing ```npm run preview```, developers can see their locally running component rendered live inside the Momen editor. This instantly closes the feedback loop, solving the critical "context gap" by showing how the component behaves with real Momen data sources and actions, dramatically accelerating development and debugging.

5. Publishing: Once complete, the developer updates the version number in package.json (adhering to semantic versioning) and runs ```momen publish```. This makes the new component and version available for use across Momen projects.

The Component Contract: Props, State, and Events

The integration between custom code and the no-code editor is managed through a well-defined and strongly-typed "contract". Every Code Component must export a specific set of TypeScript interfaces, which allows Momen's visual editor to automatically parse its properties and expose them in the configuration panel. This creates a robust and predictable system for two-way communication.

This structured approach enables powerful use cases, such as building a custom charting component that fetches its data from the Momen backend via the query API and emits an onDataPointClick event that triggers a Momen Actionflow. It also allows for the integration of any third-party npm package, from data visualization libraries to specialized form controls, giving developers access to the entire React ecosystem.

Unprecedented Observability: Mastering Application Behavior with Fully Searchable Logs

In many managed platforms, the application's inner workings remain an opaque black box, making debugging a frustrating exercise in guesswork. Momen fundamentally rejects this paradigm by committing to "Complete Visibility" through its comprehensive Log Service. This service transforms the application from a black box into a fully transparent glass box, providing developers with the deep observability needed to monitor, debug, and optimize application behavior with precision.

A Centralized Nervous System for Your App

The power of the Log Service stems from its comprehensive scope, designed to "capture all key information within the system". This is a direct architectural benefit of Momen's unified full-stack nature, where frontend interactions, backend logic, and database operations are managed in a single, cohesive environment. The service provides detailed, categorized logs for every critical layer of the application stack, including:

• Actionflow: Traces the execution of each node in server-side workflows.

• Database Operations: Records every create, read, update, and delete (CRUD) operation.

• AI: Captures the full context of AI agent conversations and model interactions.

• API: Logs all requests to both internal and external APIs.

• Trigger: Records the activation of scheduled, database, or webhook-based triggers.

• Gateway: Monitors all HTTP requests to the backend.

• Deployment and Release: Tracks every backend release and deployment event.

• GraphQL: Provides detailed logs for all backend GraphQL requests.

This holistic logging is not an afterthought; it is an emergent property of the platform's foundational architecture. Because all backend requests use GraphQL, the data flowing through the system is inherently structured and predictable. This makes it possible to generate richly detailed, queryable logs for every transaction, turning the promise of "Complete Visibility" into a tangible reality.

Surgical Precision in Debugging

Momen's Log Service is far more than a simple stream of text; it is a powerful, searchable database designed for developers. It features a sophisticated query syntax that allows for surgical debugging and analysis. Developers can move beyond simple keyword searches and employ a range of operators to rapidly isolate issues:

• Field Queries: Target specific fields, such as requestMethod: POST.

• Wildcard Searches: Use wildcards for fuzzy matching, like traceId: 20241024*.

• Numeric Range Queries: Filter by value ranges, for instance, responseSize: [5000 to 10000].

• Boolean Logic: Combine conditions with and / or for complex queries, such as account and status: 200.

• Nested Field Queries: Drill down into JSON objects, a common necessity for modern APIs, with queries like requestBody.query: mutation*.

A standout feature is the universal traceId, a hallmark of enterprise-grade systems. This identifier allows a developer to follow a single user request end-to-end across the entire system—from the initial frontend-initiated request captured in a Gateway log, through the business logic in an Actionflow log, to the final write in a Database Operations log. This capability is indispensable for debugging complex, multi-step processes like payment flows or AI-driven workflows, providing definitive proof that Momen is engineered for serious, scalable applications that can support millions of users from day one.

The Road Ahead: Momen's Vision for Even More Developer Control

While Momen already provides a powerful suite of tools for its developers, we are still very far from what we envision. Here is a non-exhaustive list of planned features, aimed to even better address key areas of the development lifecycle, further bridging the gap between no-code speed and the level of control that all developers desire.

Interactive Debugging with Breakpoints and State Inspection

Momen plans to move beyond log-based analysis with a true In-App Debugger. Currently, while frontend has a crude debugger built in Mirror, debugging backend relies on analyzing detailed logs and inspecting network requests, a process that is powerful but reactive. The upcoming debugger is set to introduce the ability to pause and inspect your app's state at any moment, allowing developers to set breakpoints, examine variables, and step through logic in real-time. This feature, which is a standard in professional IDEs, will provide the granular control needed to fine-tune complex application behavior and dramatically accelerate troubleshooting.

Real-Time System Observability

Building on the principle of "Complete Visibility," Momen aims to provide deeper insights into application performance with a real-time activity monitor. Inspired by tools like macOS's Activity Monitor, this feature would offer a live dashboard of system health, showing active tasks, CPU and memory usage, and other performance metrics. This represents a significant evolution from the current Log Service, which excels at post-mortem analysis, to a proactive monitoring tool that gives developers a live pulse on their application's operational status and resource consumption.

Advanced Version Control and Release Management

To support more complex team-based development, Momen is looking to implement a more sophisticated version control system. Currently, the platform lacks the branching and merging capabilities found in mature competitors. The introduction of a Git-style workflow would be a transformative addition, enabling parallel development, feature experimentation in isolated branches, and structured release pipelines. This would elevate Momen's collaboration features to align with the best practices used by professional software teams worldwide, moving beyond simple versioning for individual assets like Actionflows.

A Versioned Database

As applications grow, the challenge often shifts from managing schema changes to understanding the history of the data itself. For auditing, debugging complex state transitions, or performing data forensics, simply knowing when a record was last updated is insufficient. The critical need is to answer: "What did this specific row look like at a previous point in time?"

To address this, the vision is to implement a true row-level versioning system, enabling Point-in-Time Recovery (PITR) for every individual record. UPDATE or DELETE operation would not discard the old data; instead, it would archive the previous version of the row into a history table, marking the exact period it was valid.() This creates a complete, immutable audit trail for every piece of data in the application.

Such a system would allow developers to "time travel" through their data, querying the state of any row AS OF a specific timestamp. This granular recovery and analysis capability is invaluable for safely rolling back incorrect data modifications, understanding data evolution without restoring an entire database backup, and building applications with institutional-grade auditability. Momen's foundation on a native, high-performance PostgreSQL database provides the ideal architecture to build this powerful feature, abstracting the complexities of manual versioning into a seamless platform capability.

Dedicated Runtimes with Node.js

For developers requiring maximum control, the future involves offering a fully-fledged, Node.js-compatible Custom Code runtime environment for projects running on single-tenant servers. This would empower developers to move beyond isolated JavaScript snippets in Actionflow and deploy entire server-side applications using the familiar Node.js ecosystem. This runtime would extend the current ACID guarantees offered in the Synchronous Actionflows. This would offer the ultimate level of backend control: the full power and flexibility of a standard Node.js environment combined with the reliability and managed nature of Momen's transactional, PostgreSQL-backed data layer.

Conclusion: True Control is the Freedom to Choose

The four pillars of developer control—GraphQL, JavaScript logic, React Components, and Logs —demonstrate that Momen is engineered to be more than just a no-code platform. It is a productivity platform that respects developer expertise and provides the tools necessary to build sophisticated, scalable, and truly custom applications.

• A Universal Data Layer via the self-documenting GraphQL API offers efficient, flexible integration and the option to use Momen as a headless backend.

• Server-Side Superpowers via JavaScript in Actionflow allow for the implementation of any proprietary business logic.

• Infinite Frontend Flexibility via Code Components ensures that the UI is never a limitation.

• Unprecedented Observability via the Log Service provides the transparency needed for robust debugging and monitoring.

Momen is not "anti-code". It is "pro-productivity". The platform automates the vast majority of development that is repetitive and undifferentiated—such as CRUD operations, deployment pipelines, and server scaling—freeing developers to focus their unique skills on the rest that creates competitive advantage. It offers the velocity of visual development without the constraints, creating a powerful environment where you can build faster without ever hitting a wall.