Application Generator¶

Overview¶

The Application Generator lets you build a complete, working application from a plain-language description in about 10 minutes. Simply describe what you want ("I need a task management app with projects and teams"), and Magieva generates the database schema, API endpoints, UI components, and deployment configuration for you.

Quick Start¶

1. Describe Your Application¶

Navigate to: Dashboard → Generate Application

Enter a natural-language description of what you want to build.

Example:

Build a task management application where users can:
1. Create projects with name and description
2. Add tasks to projects with title, due date, and priority
3. Assign tasks to team members
4. Track task status (to-do, in-progress, done)
5. View a dashboard with project progress and upcoming deadlines

Tips for a Good Description: - Be specific about features and functionality - Mention user roles (admin, member, guest) - Specify data relationships (a project has tasks, a task has an assignee) - Describe the UI you want (dashboard, forms, tables) - Mention any integrations you need (OAuth, email notifications, webhooks)

2. Review the Generated Architecture¶

Magieva analyzes your description and shows you a preview before generating any code, including:

Database schema — an ERD diagram of the tables and relationships it plans to create
API endpoints — the list of endpoints it will generate
UI components — the pages and components it will build
Integrations — any OAuth providers or webhooks it will configure
Estimated generation time

Review this preview before proceeding to make sure it matches what you had in mind. If something looks off, adjust your description and try again.

3. Customize Configuration (Optional)¶

Preferences: - Primary color — your brand color (hex code or color picker) - Font family — e.g. Inter, Roboto, Poppins - Database — PostgreSQL (default), MySQL, or MongoDB - Backend language — Go (default), Node.js, or Python - Frontend framework — Next.js (default), React, or Vue

Advanced Options: - Authentication — JWT (default), OAuth only, or a custom setup - Deployment target — Cloud Run (default), Kubernetes, or Vercel - Custom domain — point your own domain at the deployed app

4. Start Generation¶

Click Generate Application to begin. You'll see live progress through each stage:

Analyzing your description — extracting requirements
Generating the schema — creating database tables and access policies
Generating the API — creating endpoints with authentication and validation
Generating the UI — creating components styled with your branding
Generating integrations — creating OAuth configs and webhook handlers
Packaging — bundling all generated files
Deploying (optional) — publishing your app if you chose automatic deployment

While generation runs, you'll see a progress bar, the current step, the number of files created, and a time-remaining estimate.

5. Download or Deploy¶

A. Download the Generated Code - Click Download ZIP - Extract the archive - Follow the included README.md for setup instructions - Deploy to your own infrastructure whenever you're ready

B. Deploy Automatically - Click Deploy to Cloud Run - Enter a service name (e.g., "task-management-app") - Configure environment variables (database URL, JWT secret, etc.) - Wait for deployment to finish - Access your app at the URL shown once deployment completes

What Gets Generated¶

Database Schema¶

Magieva creates the tables, relationships, and access policies your application needs. For example, a task management app might generate:

-- projects table
CREATE TABLE projects (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    name VARCHAR(255) NOT NULL,
    description TEXT,
    created_by UUID NOT NULL REFERENCES auth.users(id),
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

-- tasks table
CREATE TABLE tasks (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
    title VARCHAR(255) NOT NULL,
    description TEXT,
    due_date DATE,
    priority VARCHAR(20) CHECK (priority IN ('low', 'medium', 'high')),
    status VARCHAR(20) CHECK (status IN ('to-do', 'in-progress', 'done')),
    assigned_to UUID REFERENCES auth.users(id),
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

-- Row-level security ensures users only see their own data
ALTER TABLE projects ENABLE ROW LEVEL SECURITY;
CREATE POLICY "Users can view their own projects"
    ON projects FOR SELECT
    USING (created_by = auth.uid());

-- Indexes for performance
CREATE INDEX idx_tasks_project ON tasks(project_id);
CREATE INDEX idx_tasks_assigned_to ON tasks(assigned_to);

API Endpoints¶

Magieva generates working API handlers with validation, authentication, and error handling. Example endpoints for a project/task app:

GET /api/v1/projects — List projects
POST /api/v1/projects — Create a project
GET /api/v1/projects/:id — Get project details
PUT /api/v1/projects/:id — Update a project
DELETE /api/v1/projects/:id — Delete a project
GET /api/v1/tasks — List tasks (with project filter)
POST /api/v1/tasks — Create a task
PUT /api/v1/tasks/:id — Update a task
DELETE /api/v1/tasks/:id — Delete a task

UI Components¶

Magieva generates working, styled front-end pages using your chosen framework and branding — for example, dashboards, list views, and detail pages that call the generated API directly.

Typical generated pages: - Dashboard with key metrics - Project list and detail views - Task list - Team members page

Integration Configurations¶

If your description mentions authentication providers or webhooks, Magieva generates the necessary configuration, including an environment variable template (.env.example) covering things like:

Database connection string
JWT secret and expiration
OAuth client IDs/secrets for providers like Google and GitHub
Server port and log level

You fill in the actual secret values before deploying.

Deployment Options¶

Option 1: Automatic Deployment (Cloud Run)¶

Magieva can build and deploy your application for you, including: - Building a container image from the generated Dockerfile - Deploying with automatic scaling - Configuring your environment variables - Setting up HTTPS

Accessing your app: - A hosted URL is issued automatically when deployment completes - You can point a custom domain at that URL through your DNS settings

Scaling: Automatic deployments scale down to zero when idle and scale up under traffic, so you only pay for what you use. See the pricing page for details.

Option 2: Kubernetes (Manual)¶

Magieva also generates Kubernetes manifests (k8s/deployment.yaml, k8s/service.yaml, k8s/ingress.yaml) you can deploy to your own cluster:

# Authenticate and select your project
gcloud auth login
gcloud config set project YOUR_PROJECT_ID

# Create a cluster (if needed)
gcloud container clusters create my-cluster --num-nodes=3

# Deploy the application
kubectl apply -f k8s/deployment.yaml
kubectl apply -f k8s/service.yaml
kubectl apply -f k8s/ingress.yaml

# Get the external IP
kubectl get ingress

Option 3: Self-Hosted (VPS, DigitalOcean, AWS, etc.)¶

You can deploy the downloaded ZIP to any server that supports Docker:

# 1. Copy the ZIP to your server
scp app.zip user@your-server.com:/home/user/

# 2. SSH into the server
ssh user@your-server.com

# 3. Extract and start the app
unzip app.zip
cd app
docker compose up -d

# 4. Access it at http://your-server.com:8080

Customizing After Generation¶

Generated code is meant to be a solid, working starting point — not a black box. You're free to modify it however you like.

Download the ZIP and extract it
Open the project in your IDE

Install dependencies:

# Backend
go mod download

# Frontend
cd app && npm install

Make your changes

Test locally:

# Backend
go run main.go

# Frontend
npm run dev

Deploy your modified version

Common customizations: - Add new fields to the database - Adjust UI styling (colors, fonts, layout) - Add custom business logic or validation - Integrate additional APIs - Add authentication providers - Add email notifications

Regenerating¶

If you need to start over: 1. Return to the Application Generator 2. Update your description with new requirements 3. Generate a new version 4. Merge your custom changes back in if needed

Tip: Initialize a git repository right away so you can track and merge changes between generated and customized code.

Advanced Features¶

Multi-Language Support¶

Backend languages: - Go (default) — fast, compiled, strongly typed - Node.js — JavaScript/TypeScript, large ecosystem - Python — well-suited to data science and ML integrations

Frontend frameworks: - Next.js (default) — React with server-side rendering, good for SEO - React — client-side rendering, fast and flexible - Vue — a progressive framework with a gentle learning curve

Custom Templates¶

You can use your own code templates instead of the defaults:

Create a custom template in your Template Library

Reference it in your description, e.g.:

Build a task app using my custom API template (template_id: abc123)

The generator uses your template in place of the default one

Limitations¶

There are limits on the number of endpoints and tables supported per generation, and on maximum generation time. Refer to the pricing page for details on your plan's limits.
Supported languages: Go, Node.js, Python (backend); Next.js, React, Vue (frontend)

Troubleshooting¶

Generation fails with "Invalid intent"¶

Be more specific in your description
Include entity names, relationships, and features
Explicitly mention the UI you want
Example: instead of "task app," write "task management app with projects, tasks, and team collaboration"

Generated code has compilation errors¶

Download the ZIP and review the error details
A common cause is missing dependencies — run go mod tidy or npm install
If the issue persists, contact support@magieva.com with your generation ID

Automatic deployment fails¶

Confirm your deployment account/credentials are configured correctly
Verify billing is enabled where required
Make sure your chosen service name doesn't conflict with an existing one
Check the deployment logs for more detail

Generated UI doesn't match my branding¶

Confirm your primary color is set correctly in preferences
Upload your brand assets to your asset library before generating
Regenerate with the correct preferences, or download the ZIP and customize manually

Best Practices¶

Writing Good Descriptions¶

✅ Good example:

Build a customer relationship management (CRM) system where:
- Sales reps can create and manage customer records with contact info, company, and deal value
- Deals move through pipeline stages: Lead, Qualified, Proposal, Negotiation, Won, Lost
- Dashboard shows total deal value, win rate, and upcoming follow-ups
- Email integration logs customer communications
- User roles: Admin (full access), Sales Rep (own customers only)

❌ Weak example:

Make a CRM app with customers and deals.

A good description is specific about entities, features, UI, user roles, permissions, and business logic. A vague description leaves too much for the generator to guess.

Testing Generated Applications¶

Before deploying to production: 1. Test locally on your own machine first 2. Test all core operations — create, read, update, delete 3. Test authentication — login, logout, permissions 4. Test edge cases — empty inputs, invalid data, error states 5. Load-test with realistic concurrent traffic 6. Review for common security issues (e.g., injection, XSS)

Maintaining Generated Applications¶

Initialize version control immediately
Use feature branches for new development
Add unit and integration tests
Set up logging and error monitoring in production
Keep dependencies up to date

FAQs¶

Q: Can I generate mobile apps? A: Not currently — the generator supports web application backends and frontends.

Q: How accurate is the generated code? A: Generated code compiles and runs successfully the large majority of the time. Complex business logic may need minor manual adjustments.

Q: Can I regenerate with changes? A: Yes — update your description and generate again. Use git to merge the new output with your customizations.

Q: What databases are supported? A: PostgreSQL (default), MySQL, and MongoDB, all with generated ORM code and migrations.

Q: Can I use my own preferred AI models? A: Yes — set your AI model preference in your account settings, and the generator will use it.

Q: How do I add features later? A: Download the ZIP, add the features manually, and redeploy.

Getting Help¶

Documentation: https://docs.magieva.com
Support: support@magieva.com