Assembling the Base Platform

Assembling the Base Platform is the stage where selected Business Systems are combined into a cohesive, functioning application. This process establishes the foundational structure of the platform, its routing, navigation, backend logic, schema, and shared UI. By this point, the workflow is understood, the required systems are selected and version-pinned, and the platform is ready to take shape.

The goal of this step is not to finalise the platform but to create a complete, stable baseline on which workflow-specific customisations can be added. Assembly transforms modular systems into a unified product.

Why Assembly Matters

Assembly is one of the most important stages in the Innopo process. It ensures that each selected Business System is integrated correctly, follows shared conventions, and behaves predictably within the larger structure of the platform.

Key benefits:

• Rapid functional progress: The platform gains immediate capabilities through modular systems.
• Architectural consistency: All systems share the same structure, patterns, and design language.
• Clear separation of concerns: Reusable systems sit below custom logic, preventing code overlap.
• A stable foundation: Future enhancements are built on a proven, versioned baseline.

What Happens During Assembly

Assembly transforms individual systems into a functioning platform. This includes connecting routing structures, merging schemas, configuring backend logic, and establishing UI patterns.

The assembly process includes:

• Installing selected Business Systems into the project’s structure.
• Pinning each system to its selected version.
• Integrating UI components into the platform’s layout shell.
• Merging Prisma schema definitions while following naming conventions.
• Registering backend routes, server actions, and workflow hooks.
• Ensuring the platform’s navigation reflects the assembled systems.
• Validating that all systems operate correctly together.

By the end of assembly, the platform is structurally complete and capable of running foundational workflows such as onboarding, login, submissions, or navigation, even before customisation begins.

Creating the Unified Interface Shell

Every platform built with Innopo uses a shared base layout. This shell ensures consistency across systems and simplifies the assembly process.

The unified shell includes:

• Global navigation and sidebar layout.
• Top-level routes inherited from the Systems Library.
• User context, session management, and permissions.
• Global styling based on shadcn components.
• A consistent page structure for all systems.

This shared foundation prevents fragmentation between systems and makes the platform feel seamless to the user.

Schema Integration

Each Business System contributes its own Prisma schema models. Assembly involves merging these models into a unified data layer while maintaining clear boundaries between systems.

Schema integration steps:

• Insert schema models following naming conventions.
• Validate relationships between models (if any).
• Run initial migrations for the combined schema.
• Document any custom fields or workflow-specific relationships.

A consistent schema allows systems to remain modular while still interoperating smoothly.

Backend Logic Integration

Systems include server actions, route handlers, validation rules, automation logic, and integrations. Assembly registers these backend elements into the project, creating a unified operational backend.

Typical backend integrations:

• Authentication and session workflows.
• Submission handlers for forms and multi-step processes.
• Event-triggered automation hooks.
• Document or PDF generation endpoints.
• Task routing for admin or reviewer roles.

Validation and Testing

Before moving to Workflow Customisation, the base platform is tested to ensure that all systems operate correctly together.

Validation includes:

• Testing UI flows for each system.
• Verifying schema relationships.
• Checking authentication and permissions.
• Testing backend routes and server actions.
• Ensuring pages load and route as expected.

A validated base platform prevents downstream issues when custom logic is added in the next step.

What Assembly Does Not Include

Assembly deliberately does not introduce any partner-specific logic. This separation keeps systems clean and reusable.

Assembly does not include:

• Branding or custom styling.
• Unique approval or pricing flows.
• Partner-specific data fields.
• Third-party integrations tied to a single project.
• Any logic that cannot be reused across multiple platforms.

These areas belong to Step 4 — Workflow Customisation.

Summary

Assembling the Base Platform transforms modular Business Systems into a functional, unified application. It integrates UI, backend logic, schema models, and navigation into a cohesive structure. By the end of this step, the platform is fully operational with foundational behaviours in place, ready for the custom workflow logic introduced in Step 4.