Platform documentation

Publish from the platform

The fastest way to go live is the Publicar button in the screen editor. One click starts a full production pipeline—no export, no local CLI, no manual Vercel setup.

Mindbuilder handles provisioning and deploy for you: it creates the project on Vercel, sets up a Postgres database (Neon), configures Blob storage when needed, syncs environment variables, and runs the production build remotely.

• Open the project in the screen editor.
• Click Publicar.
• Watch the status bar until the deployment is ready.
• Open the live URL with Abrir site.
• Republish anytime after you change screens, data, or settings.

Integrate GitHub

Integrar GitHub creates (or reuses) a private repository and pushes the exported project so your team can work in git—and so Publicar can deploy from main.

In the screen editor, click Integrar GitHub and paste a Personal Access Token with the `repo` scope (or reuse a token already saved on the project). Mindbuilder creates a private repo if needed, pushes the export tree, and stores the link on the project.

After a successful sync, Abrir código opens the repository in github.dev (the browser IDE). Later publishes use that remote as the deploy source when the integration stays active.

• Click Integrar GitHub in the screen editor toolbar.
• Paste a GitHub PAT with `repo` scope (classic or fine-grained with repo access).
• Follow the status bar: exporting → creating repo → pushing → ready.
• Use Abrir código to open github.dev, or open the repo URL on GitHub.
• Keep pushing to `main` (or re-run Integrar GitHub) so Publicar stays in sync.

Local development

When you need to inspect the code, debug, or extend the system beyond the editor, export the project and run it on your machine with the included scripts—or clone the GitHub repo after Integrar GitHub.

Every export includes `run.ps1` (Windows) and `run.sh` (Linux/macOS) at the project root by default. These scripts install dependencies when needed and start the local app—you do not need to wire `npm` commands by hand for a first run.

Local development is ideal for custom logic, reviewing generated structure, integrating with your own services, or preparing a repo for your team’s Git workflow. It complements one-click publish; it does not replace it.

• Node.js 22.x installed on your machine.
• Export the project from Mindbuilder (ZIP) and unzip it—or clone the GitHub repo.
• Open a terminal at the export root (where `run.ps1` / `run.sh` live).
• Run the script for your OS — it prepares and starts the project.
• Open the app at http://localhost:3000 (API under `/api` for Next.js exports).
• Review `.env` / `.env.local` before production (database, JWT, OAuth, Stripe, etc.).

# From the exported project root
.\run.ps1
# App: http://localhost:3000

# From the exported project root
chmod +x run.sh && ./run.sh
# App: http://localhost:3000

Deploy with Vercel CLI

Prefer to deploy yourself from an export? Use the included Vercel scripts. This is an optional path—most teams can stay with Publicar on the platform.

Each export includes a deploy script at the project root: `deploy-vercel.ps1` on Windows and `deploy-vercel.sh` on Linux/macOS. Run it from the exported folder after installing the Vercel CLI.

You will need a Vercel account, the CLI logged in, and a Postgres database connected via a Vercel integration (Neon, Vercel Postgres, or Supabase).

• Vercel CLI — installed and authenticated. How to install Vercel CLI
• Node.js 22.x and npm — required on your machine.
• PostgreSQL — connect via a Vercel integration before or right after the first deploy.

cd project_export_root
.\deploy-vercel.ps1

cd project_export_root
chmod +x deploy-vercel.sh && ./deploy-vercel.sh

Multitenant boilerplate

Multitenant mode lets a single deployed app serve many customers while keeping each customer's data isolated.

Think of it as one application, many workspaces. Each organization has its own records—clients, orders, invoices, and anything else you modeled—without seeing another organization's data.

Users belong to an organization. When someone signs in, they work inside their organization's context. If you build a B2B SaaS, an agency portal, or an internal tool for multiple branches, multitenant is the foundation that keeps everything separated cleanly.

• One deployment, multiple organizations — no need to spin up a new instance per client.
• Data isolation by organization — each tenant only sees what belongs to them.
• Users tied to organizations — access is scoped to the workspace they belong to.
• Ideal for SaaS, franchises, agencies, and multi-branch businesses.

Users

User management covers who can access your app, how they sign in, and what they are allowed to do.

Exported apps support sign-in with Google, Microsoft, or email and password. You choose which methods to enable in the Mindbuilder editor before export.

Some screens and actions are public; others require authentication. Admin areas can be limited to specific people—for example, operators who manage the whole system versus regular members of an organization.

• Social login — let users sign in with existing Google or Microsoft accounts.
• Email and password — classic registration for apps that need it.
• Protected areas — only signed-in users reach dashboards and sensitive screens.
• Admin access — separate elevated permissions for operators and support staff.

Subscriptions

Subscriptions turn your app into a paid product with recurring plans—monthly or annual billing managed automatically.

When Stripe is enabled, exported apps can offer checkout, plan upgrades, and cancellation flows. Customers subscribe to a tier (for example Free, Pro, or Enterprise) and billing renews on a schedule.

Plans can unlock features or raise limits—more projects, more storage, or access to premium screens. On the Mindbuilder platform itself, plans control how many projects you can create.

• Recurring billing — charge customers on a schedule without manual invoices.
• Multiple plans — free tier to acquire users, paid tiers for growth.
• Self-service checkout — users upgrade or manage billing from inside the app.
• Plan-based limits — tie features and quotas to the active subscription.

Business automations

Automations are business rules that run automatically when records are created, updated, or deleted—no manual intervention required.

You define what should happen in plain terms: validate before saving, update related records, or block an action when a condition is not met. Examples include preventing a payment when an invoice is overdue, or recalculating an order total after a line item changes.

Automations live on the server side. They enforce consistency so your app behaves the same for every user, every time—regardless of which screen triggered the change.

• Lifecycle triggers — react when data is created, updated, or removed.
• Validation rules — stop invalid operations with clear error messages.
• Related updates — keep parent and child records in sync automatically.
• Business logic without custom code — configure rules in the editor before export.

Integrations

Integrations connect your exported app to external services you already rely on—GitHub, payments, analytics, file storage, and identity providers.

Enable only what you need in the Mindbuilder editor. Each integration adds the right screens and server behavior to your export, so you do not wire everything by hand.