Running a Base44 App Inside Another Base44 App

At some point, one app isn't enough.

You build a system, it works well… and then new needs appear:

• •You want users to access multiple tools in one place
• •You want to add a new product without sending users somewhere else
• •You want different features to feel like part of one system
• •You want to grow without rebuilding everything from scratch

In other words — you want to move from an app to a platform.

Here's the key insight:

👉 It is possible to run one Base44 app inside another Base44 app, so the user stays in the same environment — while actually using multiple applications.

Think of it as: An app inside an app.

Why This Matters

When all your tools live in one place, everything becomes simpler:

• •One domain
• •One user experience
• •One place to manage users
• •One place to manage payments
• •One ecosystem instead of disconnected apps

Instead of building separate systems that feel unrelated, you create a unified environment that can grow over time.

This is especially useful when:

• •Building internal tool suites
• •Creating client portals
• •Expanding a product into multiple modules
• •Designing a marketplace of features
• •Connecting several products into one experience

Why It's Not Trivial in Base44

Base44 apps are not just front-end interfaces.

Each app includes its own:

• •Data layer
• •Permissions
• •Logic
• •Internal API
• •Runtime environment

All of these operate through the app's unique subdomain.

This means the app expects to run within its own environment.

So if you simply display one app inside another, the interface might appear — but internal actions (like authentication, saving data, or loading user-specific content) may not function correctly.

To make the integration work properly, the connection must include the app's underlying environment — not just the visible UI.

That's what makes this pattern powerful, but also slightly more complex.

Questions to Ask Before Implementing

Before connecting apps together, it helps to clarify the goal:

• •Should this app be part of a larger system?
• •Should users stay under the same domain?
• •Is a unified experience important?
• •Does the embedded app rely on its own data and logic?
• •Do you want multiple tools to feel like one product?

If the answer to several of these is yes, this architecture is likely relevant.

What This Enables

Once you understand how to connect Base44 apps correctly, new possibilities open up:

• •Multiple tools under one environment
• •A unified workspace
• •Modular product design
• •Internal marketplaces
• •Shared user and billing layers
• •Scalable product ecosystems

Instead of thinking in terms of individual apps, you start designing systems made of apps.

Practical Implementation Approach

The cleanest way to embed one Base44 app inside another is using an

<iframe>

jsxCopy
// In your host app - embedding a child app
<iframe
  src={`https://your-child-app.base44.app?token=${userToken}`}
  style={{ width: '100%', height: '100vh', border: 'none' }}
  allow="fullscreen"
/>

For this to work properly:

1. •Pass authentication — the child app needs to know who the user is
2. •Match domains — use a custom domain or subdomain structure
3. •Handle communication — use
   codeCopy

   postMessage

   for cross-app interactions
4. •Sync state — decide what data lives where

Architecture Patterns

Pattern 1: Shell + Modules

One main app acts as the shell — handling navigation, authentication, and layout. Each module is a separate Base44 app embedded as a tab or section.

codeCopy
Shell App
├── /dashboard    → Main App UI
├── /analytics    → Analytics App (embedded)
├── /crm          → CRM App (embedded)
└── /billing      → Billing App (embedded)

Pattern 2: Portal + Tools

A client-facing portal hosts multiple specialized tools. Each tool is its own Base44 app with its own data and logic.

Pattern 3: Marketplace

Users can activate or deactivate specific apps within a larger ecosystem — each app is independently maintained but feels native.

Prompts That Help Build This

When working with the Base44 AI builder to implement this architecture, these prompts consistently produce strong results:

For the host/shell app:

"Create a navigation shell that embeds external apps as full-screen iframes. Add a sidebar with app icons. When a user clicks an app, load it in the main content area using an iframe. Pass the current user's auth token as a URL parameter."

For cross-app communication:

"Add a postMessage listener that receives events from embedded iframes. When the child app sends a

codeCopy

{type: 'navigate', path: '/home'}

message, handle navigation in the parent app."

For unified authentication:

"Create a backend function that generates a short-lived token for the current user. The token should be passed to child apps via URL parameter so they can authenticate without a separate login."

For state synchronization:

"When the user updates their profile in the main app, use postMessage to notify all embedded child apps to refresh their user data."

For a modular dashboard:

"Build a dashboard page with a grid of app cards. Each card shows the app name, icon, and description. Clicking a card opens the app in a modal with an embedded iframe. Add a loading state while the iframe loads."

From App to Ecosystem

Base44 makes it possible to build complete applications quickly.

But when apps can work together, the potential expands.

You are no longer limited to a single product.

You can create a structured environment where multiple apps operate together — consistently, seamlessly, and under one domain.

It is possible. It requires thoughtful architecture. And it opens the door to building much more than a single app.

Summary

| Consideration | Single App | Multi-App Ecosystem | |---|---|---| | Complexity | Low | Medium-High | | Scalability | Limited | High | | Maintenance | Simple | Modular | | User Experience | Contained | Unified (if done right) | | Team collaboration | Single team | Multiple teams possible |

The shift from building apps to designing ecosystems is one of the most powerful mental models in modern software development.

Base44 gives you the foundation. This architecture gives you the direction.