Using Fibery AI / MCP to generate custom Views, Reports and Forms on top of Fibery data

Ideas & Features Fibery AI
1

Hello Fibery team! :grinning_face:

The idea is that inside Fibery, using Fibery AI or a connected MCP client, users could generate their own custom Views, Reports, or Forms based on the data inside Fibery.

The important part is that this would allow any user (without tech skills) to create custom tools using AI (vibe coding) — not only developers. :slightly_smiling_face:

Instead of building custom code outside Fibery, users could simply describe what they want and AI could generate a custom interface on top of Fibery data.

1. First step could be read-only custom Views

If making them fully interactive like standard Fibery Views is complex, a very useful first stage could be:

  • create a custom View on top of Fibery data

  • apply filters and grouping

  • combine related entities

  • control layout

  • but keep it read-only

This alone would already unlock many real workflows. (For example, Softr.io started introducing their functionality with Vibe coding exactly like this.)

2. More flexible Reports

This could also solve some current limitations in reporting.

For example, sometimes you need to show multiple different data series on the same graph, or create more custom analytical layouts - but now it is impossible in Fibery.

AI-generated reports on top of Fibery data could make this much easier.

3. Custom Views for specific operational cases

There are also many cases where a specific custom View would be useful, but impossible to create with standard Views.

For example:

  • custom day-based views (i know about Periods, but it is not so cool now :melting_face: )

  • operational dashboards

  • combined specific views of related entities

AI could generate these interfaces dynamically.

4. Forms are also a very important area

Forms are often the entry point for heavy workflows, especially when used with webhooks and automations through tools like n8n or Make.

However current Forms are still quite limited:

  • design is not customizable

  • conditional logic is missing

  • more advanced flows are difficult to build

AI-generated forms could make this much easier (If not by functionality, then by design :grinning_face: ).

Why this could be very powerful

Fibery already provides:

  • database structure

  • relations

  • permissions

  • automations

If users could generate custom interfaces on top of that using AI, Fibery could become a platform where non-technical users build their own internal tools simply by describing them.

2

P.S. One possible reference for this idea could be how this works in Softr.

In Softr, when creating a custom interface, you first select which database the interface is connected to.
Then you immediately get access to:

  • a visual preview of the interface

  • a code editor

  • version history

  • and a chat to generate or modify the interface with AI.

For example, the interface builder allows you to select the data source and generate the UI on top of that.

Possible UX inside Fibery

In Fibery this could work in a similar way.

For example, when creating a new page (alongside View, Document, Whiteboard), there could be an option: Create with AI.

When selecting this option:

:one: A new page opens with a chat interface and the page context.

:two: Two modes could exist:

Preview mode

  • shows the interface exactly as users will see it

Creation mode

  • shows configuration + generated code

  • allows selecting which Fibery database(s) are used as the data source.

Optional improvement (future idea)

If technically possible, Creation Mode could also allow selecting elements directly on the page.

For example:

  • click a block in the interface

  • that block becomes the active context for the AI chat

So the AI edits only that part of the page, instead of regenerating the entire interface.

But even a much simpler first version would already be extremely useful! :star_struck:

That alone would unlock many new workflows.

image
image588×317 8.56 KB

image
image591×767 34.7 KB

image
image583×623 17.8 KB

3

Another potential benefit :smiley:

Another very useful outcome of this approach would be the ability to build a proper home page for users inside Fibery.

Right now many teams would like to create a clean, visually appealing internal landing page for their workspace that could include things like:

  • company-specific branding (colors, layout, design)

  • key charts and metrics

  • quick links to important views

  • embedded forms

  • operational summaries

Essentially a central dashboard or portal for the team, built directly on top of Fibery data.

If this becomes possible, it would also be great to allow workspace administrators to set a default home page for users, so when people open Fibery they land on this page by default.

This would make Fibery feel much more like a complete internal workspace for teams.

Not just multiple separate widgets placed on a page :expressionless_face: — even if they are functional — but a single cohesive interface: a management page for managers or a task-focused workspace for executors.

4

Some additional thoughts

Another important advantage of this approach is that custom pages could combine different types of elements in one place.

For example:

  • forms

  • analytics and charts

  • tables

  • buttons or quick actions

  • triggers for more complex workflows outside Fibery

This would allow teams to build highly native pages (Cobined Views, but as single page/view - not just nuber of widgets) tailored to specific departments or functional units, instead of trying to adapt standard views for every scenario.

It would also make it possible to solve many small UI limitations that are currently difficult to address inside standard Fibery views.

For example:

  • different column widths in tables

  • centering content inside cells

  • adjusting card sizes in different views

  • small layout or presentation tweaks

With AI-generated custom interfaces, many of those requests might naturally disappear, because users could simply build the exact interface they need themselves — quickly and without needing custom development. :slightly_smiling_face: