Gemini

2.5 Flash

Upgrade

Gems

Storybook

United Kingdom From your IP address • Update location

Conversation with Gemini

compare nocoDB and nocoBase

NocoDB and NocoBase are both open-source, no-code/low-code platforms, but they are built for different purposes and have distinct strengths. While both can be used to build applications without extensive coding, NocoBase is a more comprehensive application development platform, whereas NocoDB is primarily a data management tool.

Here is a detailed comparison:

Core Purpose

NocoDB: NocoDB's main focus is to provide a user-friendly, collaborative spreadsheet interface for managing existing relational databases. It turns your database (like MySQL, PostgreSQL, or SQLite) into an Airtable-like interface, simplifying data management for non-technical users. It's an excellent tool for making a database accessible and interactive without writing SQL queries.

NocoBase: NocoBase is designed as a full-fledged application development platform. It allows users to quickly build various business applications and internal tools. It emphasizes flexibility and scalability, with a focus on data model-driven design, a feature often found in low-code development.

Key Features and Functionality

Feature

NocoDB

NocoBase

Primary Use Case

Data management and visualization.

Full-fledged application development.

Data Model

Converts existing relational databases into a spreadsheet-like interface.

Built on a data model-driven core, separating data structure from the user interface.

Forms

Simple, primarily for data entry.

Flexible and powerful with drag-and-drop design, conditional logic, and validation.

Automation & Workflows

Limited, primarily offering webhooks for basic automation.

Robust, with a built-in workflow engine for designing complex business processes (e.g., approval flows, notifications) using a graphical interface.

Extensibility

Offers APIs and integrations, but less extensive.

Highly extensible with a comprehensive plugin architecture. All new functions can be developed and installed as plugins.

User Interface

Provides a smart spreadsheet interface with various views (grid, Kanban, gallery, calendar).

Provides a "what you see is what you get" (WYSIWYG) interface for administrators to configure the user-facing application.

Mobile Support

Basic.

Recently released version 2.0 with separate configuration for mobile pages to ensure a smooth experience.

Access Control

Simpler, with permission management for less complex data needs.

Flexible and in-depth, suitable for scenarios with high data security requirements and complex permission settings.

API Support

Offers open APIs (REST, SDK) for integration.

Offers open APIs for integration with other systems.

Export to Sheets

Use Cases

NocoDB: NocoDB is well-suited for scenarios where the primary need is to make a database more accessible to a team. This includes creating simple CRMs, project management trackers, inventory management systems, and internal tools that are centered around a database. It's a great choice for teams that want to collaborate on existing data without getting into the complexities of database administration.

NocoBase: NocoBase is ideal for building more complex and comprehensive business systems. It can be used to create ticketing systems, project management tools, CMS, and even ERPs (Enterprise Resource Planning) and AI systems. Its plugin-based architecture and robust workflow engine make it a strong candidate for building custom, scalable, and secure applications.

Summary

Choose NocoDB if: Your primary goal is to turn an existing database into a user-friendly, collaborative spreadsheet. You need a simple, fast way for a team to manage and visualize data without writing code.

如果出现以下情况，请选择 NocoDB：您的主要目标是将现有数据库转换为用户友好的协作电子表格。您需要一种简单、快速的方法让团队无需编写代码即可管理和可视化数据。

Choose NocoBase if: You need to build a complete, scalable, and extensible business application from the ground up. You require complex workflows, detailed access controls, and the ability to add custom functionality through a plugin system.

如果出现以下情况，请选择 NocoBase：您需要从头开始构建一个完整的、可扩展的、可扩展的业务应用程序。您需要复杂的工作流程、详细的访问控制以及通过插件系统添加自定义功能的能力。

what if i start from empty, can i use nocoDB, i dont have exists database 如果我从空开始怎么办，我可以使用nocoDB吗，我没有存在的数据库

Yes, absolutely. While NocoDB is well-known for its ability to connect to and manage existing databases, you can also use it to start from scratch with a new, empty database.

When you set up NocoDB, you can choose to create a new "base" (which is NocoDB's term for a database). When you do this, NocoDB creates and manages the underlying database for you. You don't need to be a database administrator or know SQL to get started.

Here's how it generally works:

Set up NocoDB: You can either use their cloud-hosted service or self-host it using Docker. The self-hosted option will often come with a pre-configured database like PostgreSQL or SQLite to get you started.

Create a New Base: From the NocoDB dashboard, you will have an option to "Create Base." You can then select "Start from scratch."

Build Your Data Model: Once you've created your new base, you can start building your data model directly within the NocoDB interface. This is where the "no-code" part comes in. You will create "tables" (like spreadsheets) and "fields" (columns) with various data types (text, numbers, dates, attachments, etc.).

Define Relationships: NocoDB allows you to create relationships between your tables, just like in a traditional relational database, by using "Links." This is a key feature that makes NocoDB more powerful than a simple spreadsheet.

Add Your Data: After you've set up your tables and fields, you can begin to add your records (rows) manually or import them from a CSV, Excel, or JSON file.

So, even without an existing database, NocoDB is a great tool for building a data-driven application from the ground up, all through a familiar and intuitive spreadsheet-like interface.

when i create from scratch, what database is it ? could it be any database i know like mysql, sqlserver

This is an excellent question and gets to a core concept of NocoDB's architecture.

When you create a "base" from scratch in NocoDB, it needs an underlying database to store all the data, the schema you've created (tables, fields, relationships), and NocoDB's own configuration.

By default, NocoDB uses SQLite as its internal database for new projects. This is the simplest and most common setup for self-hosting NocoDB because it requires no separate database server and stores everything in a single file. This is why you'll often see Docker-based NocoDB installations that just map a volume to a local directory—that's where the SQLite file lives.

However, NocoDB is database-agnostic, and you can absolutely change the backend database it uses for its own operations. When you run a self-hosted instance, you can configure NocoDB to use a different database as its "backend" or "internal" database.

The databases NocoDB supports for this purpose include:

MySQL

PostgreSQL

MariaDB

SQL Server

SQLite (the default)

Oracle

The choice of database for a new project is made during the initial setup of your NocoDB instance, typically by setting an environment variable or a configuration file. For example, if you're using Docker, you would set the NC_DB environment variable in your docker-compose.yml file to point to your desired database server.

So, to summarize:

If you start from scratch using the default setup (e.g., a simple docker run command), NocoDB will use SQLite.

If you want to use a different database like MySQL or SQL Server from scratch, you must first have an instance of that database running and then configure your NocoDB instance to use it as its backend.

This is a key differentiator from some other platforms. NocoDB isn't a database itself; it's a layer on top of a database. You are simply choosing which database you want that layer to sit on. This gives you the flexibility to use a robust, production-ready database like MySQL or PostgreSQL from the start, which is a major advantage for scalability and performance.

does nocoDB support any app UI ? or it just a tabl-like

That's an important point that distinguishes a powerful data management tool from a general-purpose app builder.

NocoDB is much more than just a table-like view. While the grid or spreadsheet view is the default and most prominent, it offers several other built-in "view types" to visualize and interact with your data in different ways.

These views are designed to make your data more accessible and useful for different purposes, and you can switch between them easily for any given table. The common views available in NocoDB include:

Grid View: This is the default, spreadsheet-like interface you're thinking of. It's excellent for data entry, sorting, filtering, and general management.

Form View: This allows you to create forms for data entry. You can arrange the fields, add instructions, and use it as a simple way to collect structured data from your team or even from external users via a public shareable link.

Gallery View: This view is perfect for visualizing data that has images or other rich media. It displays each record as a card, which is great for things like product catalogs, real estate listings, or employee directories.

Kanban View: A must-have for project management, this view visualizes your data as cards on a board, organized by a field like "status." You can drag and drop cards to change their status, which is a very intuitive way to manage workflows.

Calendar View: If your data includes dates, this view allows you to see your records on a calendar. This is ideal for managing events, project deadlines, or scheduling.

In addition to these core views, NocoDB also has an "App Store" where you can find and add more functionality. This includes integrations with third-party services, and NocoDB has been developing a dashboard feature that can provide a more high-level overview of your data.

However, it's crucial to understand the limitation here: NocoDB's UI is fundamentally tied to these pre-built, table-driven views. It is not a free-form "app UI builder" like NocoBase, Retool, or Budibase, where you can drag and drop a wide variety of UI components (buttons, charts, text boxes, custom components) onto a blank canvas to build a completely custom front-end application.

Think of it this way:

NocoDB: The UI is an advanced, multi-faceted viewer and editor for your database. You can change the "lens" you look at the data through (grid, gallery, etc.), but you can't build a totally new application with a custom layout and user flow.

NocoBase (and similar platforms): This is a low-code platform where the UI is a separate, customizable layer. You can use their components to design a dashboard, a user portal, or any kind of application you can imagine, all connected to your data model.

So, while NocoDB is a powerful and flexible tool for interacting with data, it's not designed for building arbitrary app UIs. Its primary purpose remains data management and visualization, albeit with more than just a basic table view.

well, manage my getyourguide tour booking with nocoDB, i want to know does it support more action for me like generate a contract as pdf or .doc from a data row

That's an excellent use case for a no-code tool, and it brings up the distinction between NocoDB's core functionality and its automation capabilities.

NocoDB's built-in functionality does not include a native document generation feature. You cannot, for example, click a button on a row to generate a PDF or Word document from a pre-defined template with your tour booking data. NocoDB's core strength is managing and visualizing the data in its various spreadsheet-like views (Grid, Kanban, Gallery, etc.).

However, this is where NocoDB's extensibility and integration options come into play. NocoDB is designed to be a data layer, not a closed system, so it is well-equipped to handle this kind of task with the help of third-party automation tools.

Here's how you can achieve your goal of generating a contract or PDF:

The "NocoDB + Automation Platform" Solution

This is the most common and effective method. You will use NocoDB to manage your booking data and a separate, specialized automation tool to handle the document generation. The two platforms will communicate via webhooks or APIs.

The process would look like this:

NocoDB as the Data Hub: You would have a table in NocoDB to manage your GetYourGuide tour bookings. This table would contain all the necessary information, such as:

customer_name

booking_id

tour_name

booking_date

total_cost

contract_status (e.g., "Pending," "Generated," "Sent")

The Automation Platform: You would use a no-code automation platform like Make (formerly Integromat) or n8n. These platforms specialize in connecting different applications and automating workflows. They have hundreds of pre-built integrations.

Create the Workflow:创建工作流：

Trigger: Set up a "webhook" or "watch records" trigger in your automation platform. This trigger will listen for a specific event in your NocoDB base. For example, you could have a button in NocoDB that, when clicked, updates a field (e.g., changes "Contract Status" to "Generate Contract").触发器：在自动化平台中设置“Webhook”或“监视记录”触发器。此触发器将侦听 NocoDB 库中的特定事件。例如，您可以在 NocoDB 中有一个按钮，单击该按钮会更新字段（例如，将“合同状态”更改为“生成合同”）。

Action 1 (Get Data): When the trigger fires, the automation platform will read the row data from NocoDB for that specific booking.

Action 2 (Generate Document): The automation platform will then send this data to a document generation service. This could be:

A dedicated document automation tool: Services like DocsAutomator or Plumsail are designed for this. You would have a template (e.g., a Google Doc, Word Doc, or PDF) with placeholders like {{customer_name}}, and the service would populate the placeholders with the data from NocoDB.

An API-based solution: If you are a bit more technical, you could send the data to a custom-coded API endpoint that uses a library (like wkhtmltopdf or a similar tool) to create a PDF from an HTML template.

Action 3 (Save/Share): Once the document is generated, the automation platform can perform another action, such as:

Uploading the PDF to a cloud storage service (e.g., Google Drive, Dropbox, AWS S3).

Attaching the PDF to an email and sending it to the customer.

Updating the original record in NocoDB with a link to the generated document.

How this works with NocoDB's Strengths

This approach leverages what NocoDB is best at: being a powerful, API-driven data backend. Instead of trying to be an all-in-one app builder, it focuses on providing clean, accessible data that other tools can consume and act upon. The use of webhooks and a robust REST API makes this kind of integration seamless.

In summary:

You can't do it with just NocoDB's native UI, but you can easily achieve your goal by using NocoDB as the data source in a workflow managed by an automation platform like Make or n8n. This is a common and powerful pattern in the no-code/low-code world.

does nocoBase support my needs?

Yes, NocoBase is a much better fit for your specific needs, and it can likely handle the task of generating PDF/DOC contracts directly within its platform.

This is a key area where NocoBase's more comprehensive, application-building approach shines compared to NocoDB's focus on data management.

Here's why NocoBase is a strong solution for you:

1. Built-in Workflow Engine

Unlike NocoDB, which relies on external automation platforms like Make or n8n for complex workflows, NocoBase has a powerful built-in workflow engine. You can use a graphical interface to create a flow that is triggered by a specific event.

For your tour booking scenario, a workflow could be triggered when:

A new tour booking record is created.

A user clicks a custom button on a record (e.g., "Generate Contract").

A specific field's value changes (e.g., contract_status changes to "Generate").

This integrated workflow system means you don't need to connect to another service to automate the process, keeping everything contained within your NocoBase application.

2. Document Generation Plugin

This is the most direct answer to your question. NocoBase has a dedicated "Template Print" plugin. This is a powerful feature that allows you to:

Use templates: You can create templates in standard formats like Word (.docx), Excel (.xlsx), or PowerPoint (.pptx).

Set placeholders: Within the template, you use placeholders (e.g., {{customer_name}}, {{tour_name}}) that correspond to the fields in your NocoBase table.

Dynamic generation: The plugin will automatically fill the data from your selected record into the template.

PDF output: Crucially, this plugin supports generating the final document in various formats, including PDF.

This means you can have a pre-designed contract template, and with a simple button click or an automated workflow step, NocoBase will populate it with the correct booking data and output a professional PDF.

3. Comprehensive Application Building

Your need for generating a contract is just one step in a larger process. With NocoBase, you can build the entire application around this process, including:

Custom UI: Design a custom UI for your tour booking management. You can build dashboards, client portals, and a clean interface for your team to manage bookings, all using NocoBase's drag-and-drop page builder.

Role-Based Access Control: You can set up granular permissions so that only certain team members can access sensitive booking data or generate contracts.

External Data Integration: You can still integrate with external systems via its API or other plugins if needed (e.g., pulling data from an external booking system), but the core functionality of generating the contract would be handled internally.

Summary

Feature

NocoDB

NocoBase

Document Generation

No native support. Requires external automation tools (Make, n8n) and a document generation service.

Yes. Has a "Template Print" plugin for generating Word, Excel, PowerPoint, and PDF documents from data and templates.

Workflows

Limited to basic webhooks. Requires external automation platforms for complex logic.

Yes. Has a robust, built-in workflow engine for designing complex business processes directly in the platform.

Core Purpose

A collaborative data manager and viewer for databases.

A full-fledged application development platform for custom business systems.

Best For You

Manage and visualize your tour data in a simple, collaborative spreadsheet.

Build a complete, custom application to manage your tour bookings, automate contract generation, and create a user-friendly interface.

Export to Sheets

Given your need for a direct, in-app solution to generate a PDF contract from a data row, NocoBase is clearly the superior choice. It has the specific features and architectural design to handle this kind of business process natively, without relying on external services.

As this needs, workflow would be: booking reach specific status, generate a contract file, send via email, update booking state 根据需要，工作流将是：预订达到特定状态、生成合同文件、通过电子邮件发送、更新预订状态

You've perfectly outlined a typical business process that is a core use case for NocoBase's workflow engine. NocoBase is designed to handle exactly this kind of multi-step automation without needing to integrate with a third-party service like Make or n8n.

Let's break down how you would build that exact workflow in NocoBase:

The NocoBase Workflow: A Step-by-Step Breakdown

Your desired workflow is:

Trigger: Booking reaches a specific status (e.g., "Confirmed").

Action 1: Generate a contract file (PDF).

Action 2: Send the contract via email.

Action 3: Update the booking's state.

Here is how you would configure this within the NocoBase platform:

Step 1: Set up the Trigger

Navigate to the Workflow Plugin: In your NocoBase application's admin panel, you'll go to the "Plugin Manager" and find the "Workflow" plugin. It's a core, built-in plugin.

Create a New Workflow: Click the "Add" button to create a new workflow. Give it a name like "Generate Contract and Email."

Configure the Trigger:

Trigger Type: Select "Collection Event." This tells the workflow to listen for changes in a specific data table (or "collection" in NocoBase terminology).

Collection: Select your "Tour Bookings" collection.

Trigger On: Choose "After updating data."

Filter Condition: This is the most crucial part of the trigger. You'll add a condition to specify that the workflow should only run when the status field is updated to the value "Confirmed" (or whatever your specific status is). This ensures the workflow doesn't trigger on every single change to a booking record.

Step 2: Add the Document Generation Node

Install the "Template Print" Plugin: If you haven't already, you'll need to go to the NocoBase Plugin Manager and install the "Template Print" plugin. This is what enables the document generation functionality.

Add the Node: Back in your workflow canvas, click the plus (+) button to add a new node. Find and select the "Template Print" node.

Configure the Node:

Select Template: Upload your Word (.docx) or Excel (.xlsx) contract template. The template will contain placeholders like {{customer_name}}, {{tour_date}}, etc.

Map Fields: The NocoBase interface will show you a list of the placeholders it found in your template. You will then map each placeholder to the corresponding field in the booking record from the trigger. For example, {{customer_name}} will be mapped to the customer_name field in your "Tour Bookings" collection.

Set Output Format: Choose "PDF" as the output format.

Set Output Path: Specify where the generated file should be saved within NocoBase's file storage. This could be a file attachment field on the booking record itself.

Step 3: Add the Email Sending Node

Install the "Email Manager" Plugin: You'll need this to handle sending emails. You can configure it to use your own SMTP server (like Gmail, SendGrid, etc.).

Add the Node: In the workflow canvas, add another node and select the "Email" or "Notification" node (depending on the specific plugin you use).

Configure the Node:

To: Use a workflow variable to specify the recipient's email address. You'll likely map this to the customer_email field from the triggered booking record.

Subject: Enter the email subject, e.g., "Your Tour Booking Confirmation and Contract."

Body: Write the body of the email. You can use variables from the booking record to personalize it.

Attachments: This is the key part. You'll attach the file that was generated by the previous "Template Print" node. NocoBase's workflow system passes the output of one node to the next, so the generated PDF file will be available as a variable to attach to the email.

Step 4: Add the Record Update Node

Add the Node: Add a final node to your workflow and select the "Update Record" node.

Configure the Node:

Collection: Select your "Tour Bookings" collection again.

Filter Condition: Specify the record to update. This will be the same record that triggered the workflow. You'll use the record's unique ID ({{$trigger.id}}) to ensure you're updating the correct one.

Update Fields: Set the value of the status field to "Contract Sent" or a similar status. This marks the booking as having completed the full process.

Final Result

Once you've linked all these nodes together and activated the workflow, NocoBase will automatically handle the entire process. The moment a user (or another part of your application) updates a booking's status to "Confirmed," the workflow will execute, and the customer will receive an email with their personalized contract, and the record in your database will be updated to reflect that the process is complete.

This level of integrated, native workflow automation is precisely why NocoBase is the right tool for this kind of task, as it provides a complete, cohesive solution within a single platform.

does nocoDB hava a UI form for data row enter , like create tour experience for my tour manager case

Yes, NocoDB absolutely has a UI form for data entry. This is one of its core features and is designed specifically to simplify the process of adding new data rows. It's a key part of what makes NocoDB a user-friendly, no-code database management tool.

Here's how it works and what it offers for your "tour manager" use case:

The "Form View" in NocoDB

NocoDB provides a "Form View" for every table you create. This view automatically generates a clean, single-page form based on the fields in your table.

Key Features for Your Use Case:

Auto-generated Fields: When you create a table for your "Tour Experiences" with fields like Tour Name, Destination, Start Date, Price, and Description, NocoDB's Form View will automatically create corresponding input fields for each.

Drag-and-Drop Editor: You can easily customize the form's layout. You can reorder the fields, add a title and description, and hide fields you don't want to be visible on the form. This allows you to create a streamlined data entry experience for your tour managers.

Field Validations: NocoDB allows you to set up basic field validations directly in the Form View. For example, you can ensure that the Price field only accepts numeric values, that the Start Date is a valid date, or that certain fields are required.

Pre-filled Forms: You can create public links to your forms with pre-filled fields. This can be very useful if you want to create a slightly different form for a specific purpose or with some data already filled in, saving your managers time.

Public and Private Forms: You can share a public link to the form, which can be used by anyone to submit data. This is perfect for collecting bookings from customers directly. Alternatively, you can keep the form private and for internal use only by your team.

Post-Submission Actions: After a form is submitted, you can configure what happens next. You can show a custom success message or automatically redirect the user to a blank form for another entry.

Example for a Tour Manager:

Let's say you have a "Tour Experiences" table. You can create a Form View and customize it for your team.

Form Title: "New Tour Experience Entry"

Description: "Please fill out the details for a new tour. All fields are required."

Layout: Arrange the fields in a logical order (e.g., Tour Name, Destination, Start Date, End Date, Description, Price, Image Attachments).

Field Validation: Set Price as a "Number" field and make it "Required."

Share: Share the link with your tour managers.

When a manager fills out the form and clicks "Submit," a new data row is automatically added to your "Tour Experiences" table, ready to be viewed in the Grid, Gallery, or Calendar views.

While the NocoDB Form View is powerful for its simplicity and direct connection to your data, remember that it's a fixed component. It's not a free-form, custom UI builder like a more advanced platform (e.g., NocoBase), but for the purpose of streamlined data row entry, it's highly effective.

how about nocoBase for this

NocoBase handles forms in a fundamentally different and more powerful way than NocoDB. While NocoDB provides a simple, auto-generated "Form View" for each table, NocoBase gives you a full-featured "Form Block" that is a core component of its drag-and-drop UI builder.

Here's how NocoBase addresses your need for a "tour manager" data entry form:

The "Form Block" in NocoBase

In NocoBase, everything is built with "blocks." A form is not just a different view of a table; it's a dedicated UI component you can add to any page or pop-up.

Key Differences and Advantages for Your Use Case:

UI Editor and Page Builder: NocoBase operates on a "what you see is what you get" (WYSIWYG) principle. You start with a blank page and add different blocks to it. You would add a "Form Block" to a new page to create your "New Tour Experience" entry form.

Customization and Layout: This is the most significant difference. You have complete control over the form's layout. You can:

Add multiple form blocks to a single page.

Mix and match form blocks with other blocks like "Table," "List," or "Markdown." For example, you could have a page with a form on the left and a list of recently added tours on the right.

Group fields, add headings, and style the form to match your brand or internal application's aesthetic.

Dynamic and Conditional Fields: NocoBase's Form Block supports advanced features like "Linkage Rules." This means you can show or hide fields based on the values of other fields. For example, you could have a checkbox for "Is this a multi-day tour?" and only show the "End Date" field if that box is checked. This creates a cleaner, more intuitive form for your tour managers.

Form for Adding or Editing: The Form Block can be configured for different purposes. You can have one form for adding new tour experiences and a separate, more detailed form for editing an existing one (which can be triggered by a button in a table or list block).

Form Actions: The Form Block has built-in actions, such as "Submit." You can configure what happens when a user clicks the submit button. This includes:

Closing a pop-up.

Redirecting to another page.

Triggering a workflow (as discussed in the previous answer, this is how you'd initiate the PDF contract generation).

NocoBase Workflow for Your "Tour Manager" Form

Create a "Tour Management" Page: In the NocoBase admin panel, create a new page.

Add a "Table Block": Add a table block to the page and connect it to your "Tour Experiences" collection. This allows your managers to see a list of all tours.

Add a "Button" to the Table Block: In the table block's settings, you can add a button (e.g., "Add New Tour").

Configure the Button's Action: Set the button's action to "Open Pop-up."

Design the Pop-up Form: In the pop-up, add a "Form Block." Configure this block to add a new record to your "Tour Experiences" collection. Arrange and customize the form fields as needed.

This setup provides a complete and professional user experience for your tour managers. They can manage all tour experiences from a single page, click a button to open a clean form for new entries, and see the new record appear in the table instantly upon submission.

Comparison Summary:

Feature

NocoDB Form View

NocoBase Form Block

Customization

Basic customization (reorder, show/hide fields, add banner).

Full control over layout, styling, and component arrangement.

Functionality

Simple data entry, public/private forms.

Data entry, editing, dynamic fields, and integration with workflows.

Complexity

Designed for simple, direct data entry.

A core component for building complex, multi-step user interfaces.

Use Case

Quick and simple forms for data collection.

Building a professional, custom UI for an internal tool or business app.

Export to Sheets

For a tour manager case, NocoBase is clearly the superior choice. It allows you to build a true application interface, not just a data entry form, that is tailored to your team's workflow and provides a much more powerful and integrated user experience.

did you know Code Wave, does it similar to nocoBase

After looking into "Code Wave," it appears that it is not a direct competitor or a similar product to NocoBase in the way that NocoDB is. Instead, "Code Wave" appears to be the name of several custom software development and digital transformation agencies. These companies offer services to build software and applications for other businesses.

It's a common name for a software development firm. The companies using the name "Code Wave" seem to focus on providing services like:

Custom Software Development: Building tailor-made web, mobile, and enterprise applications for clients.

Digital Transformation: Helping businesses modernize their operations with new technology.

UX/UI Design and Consulting: Providing design services for software and websites.

AI/ML Solutions: Developing AI-powered applications for clients.

In essence, these companies use their expertise to build software for clients, often using traditional programming and modern tech stacks.

Why This is Different from NocoBase

This is a fundamental distinction from a platform like NocoBase.

NocoBase is a product. It is a software platform that you use to build your own applications. It's a tool for a "citizen developer" or a small technical team to create business systems without writing all the code from scratch.

Code Wave is a service. It is a company that you hire to build software for you. They are the people who might use a tool (or more likely, write code) to deliver a final product.

Think of it like this:

You want to build a house.

NocoBase is like buying a pre-fabricated building kit. It has all the major components (walls, floors, plumbing connections) ready to go, and you can assemble and customize it yourself with little to no professional construction knowledge.

Code Wave is like hiring a construction company. You tell them what you want, and they will bring in their architects, engineers, and construction workers to build the house for you from the ground up, using traditional methods.

In short, NocoBase and "Code Wave" are in completely different parts of the software development ecosystem. NocoBase is a no-code/low-code tool, while "Code Wave" is a custom development service. They are not similar at all.

what would you recommand for me

Based on the detailed needs you've described—managing tour bookings, generating contracts, emailing them, and updating the booking status—here is my recommendation:

I recommend you use NocoBase.

The Case Against NocoDB

While NocoDB is a fantastic tool for what it does, it's not the right fit for your entire workflow. Its core strength is making data accessible and collaborative through a spreadsheet-like interface. It can't natively handle the key automation steps you need.

No Native Document Generation: As we discussed, you would have to rely on an external automation service (like Make) and another document generation tool. This adds complexity, cost, and potential points of failure to your workflow.

Limited Workflows: NocoDB's automation capabilities are simple webhooks. It can trigger an external process, but it can't manage the multi-step logic (generate file, send email, update record) internally.

UI Constraints: While NocoDB's Form View is good for simple data entry, it's not a true application builder. You can't create a custom, polished UI for your tour managers with a dashboard, lists, and forms all on one page.

The Case for NocoBase

NocoBase is a perfect match for your needs because it is built to handle exactly this kind of business application and automation.

Native, Integrated Workflow Engine: NocoBase's built-in workflow engine is its killer feature for your use case. It allows you to design the entire process—from the trigger (booking status update) to all the actions (generate document, send email, update record)—in one place, without external services.

Direct Document Generation: The "Template Print" plugin in NocoBase directly addresses your most critical requirement. You can upload a .docx or .xlsx template and have NocoBase automatically generate a PDF contract with data from your booking record.

True Application Builder: NocoBase's block-based UI editor allows you to build a complete and user-friendly internal application for your tour managers. You can create a dashboard that shows upcoming tours, a table with bookings, and a button to open a custom-designed form for adding a new tour, all on the same page.

Scalability and Extensibility: Since NocoBase is a more comprehensive platform, you can easily add more functionality in the future. If you need to add an approval process for a large booking, or integrate with a payment gateway, the NocoBase platform is designed to handle those complexities via its plugin system.

Final Verdict

Choose NocoBase.

While both are excellent open-source projects, NocoDB is a fantastic data management tool, while NocoBase is a true application development platform. Your specific needs—especially the workflow automation and document generation—go beyond NocoDB's core purpose. NocoBase provides a native, integrated, and more powerful solution for building the complete internal application you envision.

ok, as you mention previous, action trigger by workflow that some status update, what if i want a button for user to trigger, like a btn to Generate contract

That's a very common and powerful need in building an application. While an automated trigger (like a status update) is great for hands-off processes, a manual button trigger is essential for user-initiated actions.

Yes, NocoBase fully supports this. You can create a button on a page or a table row that, when clicked, triggers a specific workflow. This is handled through NocoBase's "Trigger Workflow" action.

Here's how you would set up your "Generate Contract" button workflow in NocoBase:

How to Create a Button to Trigger a Workflow

This process combines the UI-building features of NocoBase with its workflow engine.

Step 1: Design the UI with the Button

First, you'll need to place a button where the user can click it. NocoBase offers several places to do this:

On a Table Block: You would likely add a button to the "actions" column of your "Tour Bookings" table. This places a "Generate Contract" button directly on each row, so a tour manager can easily click it for a specific booking.

On a Detail Page: If you have a separate page for each booking record, you can add a button to the action panel at the top of the page.

On a Form: You could add the button to a form, for example, on a booking edit form.

Step 2: Configure the Button's Action

Once you've placed the button, you'll configure its behavior.

Action Type: You will set the button's action to "Trigger Workflow."

Binding: You then select the specific workflow you want the button to run. In this case, you would bind it to the "Generate Contract and Email" workflow you created.

Step 3: Configure the Workflow to be Triggered by the Button

Now, you need to slightly adjust your workflow's trigger.

Trigger Type: Instead of "Collection Event," you would use a "Post-action Event" or similar trigger type that is designed to be initiated by a user action. The NocoBase documentation notes that a "Custom action event" is a common way to handle this.

Data Context: The workflow will automatically receive the data of the record from which the button was clicked. The workflow will then use this data as its "trigger data" to execute the subsequent steps.

The Complete User Experience

By setting this up, your tour manager's workflow becomes very intuitive and efficient:

The manager is on the main "Tour Bookings" page (or an individual booking's detail page).

They find the booking they want to generate a contract for.

They click the "Generate Contract" button on that booking's row.

A pop-up or notification might appear saying "Generating and sending contract..."

In the background, the workflow you designed runs. It pulls the booking data, generates the PDF, emails it, and updates the booking status.

The manager sees the status on the booking record change to "Contract Sent."

This provides the perfect blend of manual user control and powerful backend automation, all within a single, integrated platform. This is a common and powerful pattern in no-code application building, and NocoBase handles it beautifully.

in real world case, after generate , user may need a preview for review it is currect since contract is most important in data Rigor

You've raised an excellent and realistic point. In a real-world business process, especially one involving contracts, a simple "fire and forget" automation is often not enough. You need a human review step to ensure data accuracy and integrity.

NocoBase is designed to handle this kind of human-in-the-loop workflow. You wouldn't just send the contract directly; you'd add a "review and approval" step to your process.

Here’s how you would modify the NocoBase workflow to include a preview step for your tour manager:

The "Generate and Preview" Workflow in NocoBase

This new workflow would involve a combination of automated steps and a manual intervention by a user.

Trigger: The workflow is still triggered by the user clicking the "Generate Contract" button on a booking record.

Action 1 (Generate the Draft): The first node in your workflow would be the "Template Print" node.

It pulls the data from the booking record.

It uses your contract template.

It generates the PDF file.

Crucially, instead of immediately emailing it, it saves the generated file to an "Attachment" field on the booking record. This draft file is now available for preview.

Action 2 (Notify the Manager): You can add a "Notification" node to the workflow.

This node sends an in-app notification or an email to the relevant tour manager.

The notification says something like: "A draft contract for booking #1234 has been generated and is ready for your review."

Action 3 (Review and Approval): This is where the magic happens. On your NocoBase UI page, you would create a "Detail Block" for the booking record. Within this block, you would:

Display the Attachment Field: Show the field where the generated PDF was saved. NocoBase has an "Office File Previewer" plugin that allows users to view Word, Excel, and other office files directly in the browser, without downloading them. This means your manager can click on the attached contract and get an instant preview.

Add a Form Block with "Approve" and "Reject" Buttons: You would add a small form block with two buttons: "Approve and Send" and "Reject."

Configure the "Approve" Button's Action: This button is the trigger for the next part of the workflow. When clicked, it would:

Trigger another, separate workflow (e.g., "Send Approved Contract").

Pass the record data and the attached PDF file to that new workflow.

Configure the "Reject" Button's Action: This button would also trigger a workflow. It would:

Update the contract_status to "Rejected" or "Draft Failed."

Potentially send a notification to the person who initiated the process.

Action 4 (Send Approved Contract Workflow): The new "Send Approved Contract" workflow is a simpler, automated flow.

Trigger: It is triggered by the "Approve and Send" button from the previous step.

Action 1: It uses the "Email" node to send the attached PDF from the record to the client's email address.

Action 2: It uses the "Update Record" node to change the booking status to "Contract Sent."

Why This is a Superior Solution

This two-part workflow design is the "correct" way to handle this kind of rigorous process and highlights NocoBase's power:

Data Integrity and Rigor: It puts a human in the loop exactly where needed for quality control. The manager can visually confirm every detail of the contract before it is sent.

Flexibility: You can build a robust user interface around the review process. The manager gets a clean UI to preview the document and perform the necessary action.

Audit Trail: The workflow automatically tracks the state of the booking (Draft, Under Review, Contract Sent, etc.). This creates a clear audit trail of who approved the contract and when.

No Code: All of this, from the UI design to the multi-step workflow with human intervention, can be built without writing a single line of code.

This sophisticated level of business process automation is exactly what NocoBase is built for, and it is a key reason why it's a better fit than NocoDB for your specific needs.

what database nocoBase use? sqlite or i need to prepare a external database interface?

This is an excellent and crucial question for anyone considering a self-hosted platform like NocoBase. The short answer is: both, but you need to understand the difference between the default and production-ready setups.

NocoBase is designed to be flexible and database-agnostic. It can run on a variety of popular relational databases, but its default and recommended setup for ease of use is different from its production-ready setup.

1. The Default (SQLite) Option

What it is: When you use a simple docker run command or npm create-nocobase-app without any specific database configuration, NocoBase will, by default, use SQLite as its main database.它是什么：当您使用简单的 docker run 命令或 npm create-nocobase-app 而没有任何特定的数据库配置时，NocoBase 将默认使用 SQLite 作为其主数据库。

Pros: This is the easiest way to get started. SQLite is a file-based database, so you don't need to install or configure a separate database server. All the data is stored in a single file on your system. This is perfect for local development, testing, and small, personal projects.优点：这是最简单的入门方法。SQLite 是一个基于文件的数据库，因此您无需安装或配置单独的数据库服务器。所有数据都存储在系统上的单个文件中。这非常适合本地开发、测试和小型个人项目。

Cons: SQLite is generally not recommended for production environments. It has limitations with concurrent access (multiple users writing to the database at the same time), and it's not as robust or scalable as a full-fledged database server.缺点：通常不建议将 SQLite 用于生产环境。它在并发访问（多个用户同时写入数据库）方面存在限制，并且不如成熟的数据库服务器强大或可扩展。

2. The Production-Ready (External Database) Option

What it is: For any serious application, you should prepare an external database interface. NocoBase is built to connect to a separate database server for its main operations.它是什么：对于任何严肃的应用程序，您都应该准备一个外部数据库接口。NocoBase 旨在连接到单独的数据库服务器以执行其主要作。

Supported Databases: NocoBase's documentation confirms it supports a number of relational databases, including:

PostgreSQL

MySQL

MariaDB

SQL Server (Note: SQL Server support may be an add-on or a community-supported feature, so it's always best to check the latest documentation.)

Why this is recommended: Using an external database provides several critical advantages:

Scalability: A database like PostgreSQL or MySQL is built to handle many concurrent users and a large volume of data, which is essential for a growing business application.

Performance: These databases are highly optimized for read and write operations, leading to faster application performance.

Robustness and Reliability: They offer advanced features like replication, backups, and failover, ensuring data integrity and business continuity.

Better Management: You can use standard database management tools (like DBeaver or pgAdmin) to monitor, back up, and optimize your data independently of the NocoBase application.

NocoBase's Dual-Layer Database Approach

It's also important to note that NocoBase has a sophisticated "Data Source Manager" plugin. This allows it to:

Use its "main database" (the one you configured it to run on, e.g., PostgreSQL) for all the core application data (UI definitions, workflows, user accounts, and your custom data collections).

Connect to external databases as separate data sources. This means you can build an application in NocoBase that pulls data from an existing MySQL database, a different PostgreSQL database, or even another API, and then displays and uses that data alongside the data in its main database.

Summary and Recommendation

To get started quickly and test NocoBase, use the default SQLite setup. This requires no external database.要快速入门并测试 NocoBase，请使用默认的 SQLite 设置。这不需要外部数据库。

For a real-world, production-level application like your tour booking system, you should prepare an external database. I would recommend PostgreSQL or MySQL as they are widely supported and provide the scalability and reliability you'll need.对于像旅游预订系统这样的实际生产级应用程序，您应该准备一个外部数据库。我推荐 PostgreSQL 或 MySQL，因为它们得到广泛支持，并提供您需要的可扩展性和可靠性。

The fact that NocoBase gives you the flexibility to choose your own database backend is a major advantage for building a professional and scalable application.

Sources

Tools

Gemini can make mistakes, including about people, so double-check it. Your privacy & Gemini Opens in a new window

Google Account

YT Lei

[email-masked]

Add files

Use microphone

Copy response

More

Expand text

Edit prompt

Expand menu

Storybook

Explore Gems

Gemini Apps Activity

Settings & help