Can AI Actually Build a Full-Stack Application? We Tested It

The Challenge

"Full-stack" gets thrown around loosely in AI marketing. Usually it means "we generate a frontend." Real full-stack means a frontend that talks to a backend API, a database that persists data, authentication that actually secures routes, file uploads that go somewhere, and deployment that serves real traffic. We tested whether GenMB can deliver all of that from a single prompt.

The test app: a freelancer project management tool. Clients can submit projects, freelancers can track time, upload deliverables, and generate invoices. It needs user roles (client vs freelancer), persistent data, file storage, and a deployed URL.

Frontend: What the AI Generates

The prompt: "Build a freelancer project management tool where clients submit projects with requirements and budget, freelancers track time and upload deliverables, and either party can generate invoices."

GenMB generated a React + TypeScript multi-file project in about 45 seconds. The output included:

• A login/register flow with role selection (client or freelancer)
• Dashboard with different views per role — clients see their submitted projects, freelancers see available and assigned projects
• Project detail page with requirements, budget, timeline, and status tracking
• Time tracking interface with start/stop timer and manual entry
• File upload area for deliverables
• Invoice generation with line items from tracked time

The UI used Tailwind with a clean professional layout. Responsive down to mobile. The component structure was sensible — separate files for Dashboard, ProjectDetail, TimeTracker, FileUpload, and InvoiceGenerator.

What the frontend couldn't do alone: none of this data persists. Refresh the page and everything is gone. The time tracker resets. Uploaded files go nowhere. There's no actual authentication — the "login" just sets a local variable.

This is the honest state of most AI-generated "full-stack" apps. The frontend looks complete, but it's a facade.

Adding Real Backend Services

GenMB's service detection identified what this app needs: authentication (two user roles), a database (projects, time entries, invoices), and file storage (deliverables). The platform auto-detected these from the prompt and offered to enable them.

Authentication — GenMB's built-in auth service uses Google OAuth. Enabling it injects the auth SDK into the frontend, which handles the OAuth flow, session management, and provides a getCurrentUser() function. The role system (client vs freelancer) was stored in the database alongside the user record.

Database — The Schema Designer let us define four collections: projects, timeEntries, invoices, and users (with a role field). GenMB provisioned a PostgreSQL database via DataConnect and generated the client SDK. The frontend components were regenerated to use real API calls instead of local state.

File storage — Enabling the file storage service injected the storage SDK. The FileUpload component was updated to use GenMBFileStorage.upload(), which sends files to cloud storage and returns a URL. No S3 configuration, no bucket policies — the SDK handles it through GenMB's proxy.

After enabling these three services and regenerating, the app had real persistence. Data survived page refreshes. Files uploaded to cloud storage. Login used real Google OAuth.

The Backend: What Actually Runs

For apps that need custom backend logic — in this case, invoice calculation and time aggregation — GenMB's Backend Agents handle it. A Backend Agent is a server-side process running on Cloud Run that exposes API endpoints for the frontend.

For the freelancer tool, we needed:

• An endpoint to calculate invoice totals from time entries (hourly rate x hours, grouped by project)
• An endpoint to check project budget remaining (total budget minus billed time)
• A scheduled check that flags overdue projects

The Backend Agent was generated from a description of these requirements. It produced a FastAPI service with three endpoints. The agent ran on GenMB's shared Cloud Run infrastructure — no Docker configuration, no server provisioning.

The generated backend code was functional but needed one manual fix: the invoice calculation was rounding hourly rates incorrectly (truncating instead of rounding to two decimal places). This is the kind of domain-specific logic error that Code Healer can't catch — the code runs without errors, it just produces wrong numbers. A two-line fix in GenMB Code resolved it.

Database Schema: What AI Gets Right and Wrong

The Schema Designer generated this structure:

Projects table: id, title, description, requirements, budget, status (open/in_progress/completed/cancelled), client_id, freelancer_id, created_at, deadline

Time entries table: id, project_id, freelancer_id, start_time, end_time, duration_minutes, description, hourly_rate

Invoices table: id, project_id, client_id, freelancer_id, line_items (JSON), total, status (draft/sent/paid), created_at

Users table: id, email, name, role (client/freelancer), avatar_url

What the AI got right: proper foreign key relationships, appropriate data types, sensible status enums, timestamps on everything that needs them.

What the AI got wrong: the time entries table stored duration_minutes as an integer instead of a decimal (losing partial-minute precision). The invoices table used a JSON column for line items instead of a proper line_items junction table — fine for simple invoices, but makes querying individual line items harder as the app scales. Both are reasonable choices for an MVP, not ideal for production.

Deployment: From Code to Live URL

Deploying the app to a live URL took one click. GenMB's subdomain deployment gives every app a *.genmb.com URL. The deployment process:

1. Bundle the frontend assets
2. Deploy the backend agent to Cloud Run
3. Configure the proxy layer (frontend-to-backend routing)
4. Provision the database
5. Set up the file storage bucket
6. Return the live URL

The deployed app was fully functional: Google OAuth login, persistent project data, real file uploads, working time tracking. The URL is shareable — a client could log in, submit a project, and a freelancer could pick it up.

For a custom domain, GenMB handles SSL certificate provisioning and DNS configuration. Connect projects.mycompany.com and the app is live on your domain with HTTPS.

Where Human Help Was Needed

Out of the full build, three things required manual intervention:

1. Invoice rounding — Domain-specific math error (2 lines changed)
2. Role-based route protection — The AI generated role-based UI (different dashboards per role) but didn't add route guards to prevent a client from navigating directly to freelancer-only URLs. Added with GenMB Code's AI assistant in about 5 minutes.
3. Email notifications — The prompt mentioned invoicing but didn't specify email notifications. We added "email the client when an invoice is generated" as a refinement prompt. GenMB generated the email integration using the built-in contact service.

Total manual effort: roughly 20 minutes on top of the AI generation. Compared to building this from scratch — a full-stack app with auth, database, file storage, backend API, and deployment — that's a significant reduction.

The Honest Assessment

Can AI build a full-stack application? Yes, with caveats.

What works well:

• Frontend generation with proper component architecture
• Service detection and SDK injection (auth, database, storage)
• Database schema design for standard CRUD patterns
• One-click deployment with SSL and custom domains
• Backend agent generation for simple API endpoints

What needs human refinement:

• Domain-specific business logic (financial calculations, complex rules)
• Route-level security beyond basic auth (role guards, permission checks)
• Features that weren't in the original prompt (you have to ask for them)
• Database schema optimization for scale (JSON columns, index strategy)

What AI can't do yet:

• Complex multi-service orchestration (three+ services interacting in a single flow)
• Real-time features (WebSocket-based collaboration, live updates)
• Performance tuning for high-traffic scenarios

The practical answer: AI builds 80–90% of a full-stack app correctly. The remaining 10–20% needs a developer's judgment — either your own or through AI-assisted refinement tools like GenMB Code. For MVPs, internal tools, and client demos, that ratio makes AI generation the fastest path from idea to working product.