NEXr Modeler

Overview

NEXr Modeler is an intelligent cloud architecture generation platform that automatically creates comprehensive technical and solution architectures for SAP Business Technology Platform (BTP) and other cloud environments directly from business requirements. Using advanced AI, it transforms high-level business needs into detailed, deployment-ready cloud architectures.

Built for Solution Architects

NEXr Modeler empowers architects and consultants to rapidly design enterprise-grade cloud solutions, reducing architecture design time from weeks to hours while ensuring best practices and compliance.

Why NEXr Modeler?

Traditional Database Design Challenges

Complex Tools: Legacy modeling tools are difficult to learn and use
Collaboration: Hard to collaborate on schema design with teams
Inconsistency: Schemas drift from documentation over time
Migration Pain: Manual schema migrations are error-prone
Visibility: Difficult to understand complex database relationships

The NEXr Modeler Solution

Visual Design: Intuitive drag-and-drop schema designer
Real-Time Collaboration: Multiple users design together
AI-Powered: Smart schema optimization suggestions
Auto-Migration: Generate migration scripts automatically
Multi-Database: Support for PostgreSQL, MySQL, MongoDB, and more
Documentation: Auto-generated, always up-to-date documentation

Core Capabilities

NEXr Modeler provides comprehensive database design capabilities:

Visual Schema Design

Drag-and-drop entity-relationship diagrams

Schema Versioning

Track schema changes with version control

Migration Generator

Automatic migration script generation

AI Optimization

AI-powered schema recommendations

Drag-and-Drop Tables: Add tables with a single click
Visual Relationships: Draw foreign key relationships
Cardinality: Define one-to-one, one-to-many, many-to-many
Indexes: Visualize and manage indexes
Constraints: Add unique, check, and default constraints
Canvas Controls: Zoom, pan, and organize your schema

Smart Schema Elements

Auto-Naming: Intelligent naming conventions
Quick Templates: Pre-built table templates (User, Product, Order)
Field Libraries: Reusable field definitions
Schema Patterns: Common design patterns (audit fields, soft delete)

2. Multi-Database Support

Design schemas for multiple database systems:

Relational Databases

PostgreSQL: Full support with Prisma integration
MySQL: Complete MySQL/MariaDB compatibility
SQLite: Lightweight database support
SQL Server: Microsoft SQL Server schemas
Oracle: Oracle database design
CockroachDB: Distributed SQL support

NoSQL Databases

MongoDB: Document schema design
Redis: Key-value store modeling
Cassandra: Wide-column store schemas
DynamoDB: AWS DynamoDB design

Graph Databases

Neo4j: Graph database modeling
ArangoDB: Multi-model database support

3. AI-Powered Schema Optimization

Let AI improve your database design:

Normalization Analysis: Detect normalization issues
Index Recommendations: Suggest optimal indexes
Performance Optimization: Identify bottlenecks
Security Checks: Find security vulnerabilities
Best Practices: Apply industry standards
Naming Conventions: Enforce consistent naming

4. Schema Migration Generator

Automatically generate migration scripts:

Forward Migrations: Apply schema changes
Rollback Scripts: Revert changes safely
Prisma Migrations: Generate Prisma schema files
SQL Scripts: Raw SQL migration files
ORM Compatibility: Sequelize, TypeORM, Doctrine support
Change Detection: Compare schemas to detect differences

How It Works

1. Create a Modeler Instance

Start by creating a NEXr Modeler instance from the service marketplace:

# Navigate to Service Marketplace
NEXr Cloud Dashboard → Service Marketplace → NEXr Modeler

Choose a plan based on your team size and needs

Set up your modeling workspace

Optional: Connect to existing database for reverse engineering

Create your first database schema

2. Design Your Schema

Create New Schema

Select PostgreSQL, MySQL, MongoDB, etc.

Use drag-and-drop to add entities

Add columns with data types and constraints

Draw connections between tables

Optimize with appropriate indexes

Reverse Engineering

Import existing database schemas:

1. Connect to Database
2. Select Tables to Import
3. NEXr Modeler Auto-Generates ERD
4. Refine and Modify as Needed

3. Generate Code & Migrations

Export your schema in multiple formats:

Prisma Schema: .prisma files
SQL Scripts: CREATE TABLE statements
Migration Files: Timestamped migration scripts
ORM Models: TypeORM, Sequelize, etc.
Documentation: Markdown, HTML, PDF

┌──────────────────────────────────────────────────────────────┐
│  NEXr Modeler - E-commerce Database          [Save] [Export] │
├──────────────────────────────────────────────────────────────┤
│  ┌─────────┐  Tools                                          │
│  │ + Table │  • Add Table    • Add Relationship              │
│  │ + View  │  • Add Index    • Add Constraint                │
│  │ + Enum  │  • AI Optimize  • Generate Migration            │
│  └─────────┘                                                  │
│                                                                │
│    ┌──────────────┐         ┌──────────────┐                 │
│    │ users        │         │ orders       │                 │
│    │──────────────│         │──────────────│                 │
│    │ id (PK)      │────┐    │ id (PK)      │                 │
│    │ email        │    │    │ user_id (FK) │◄────────┐       │
│    │ full_name    │    │    │ total_amount │         │       │
│    │ created_at   │    │    │ status       │         │       │
│    └──────────────┘    │    │ created_at   │         │       │
│                        │    └──────────────┘         │       │
│                        │           │                 │       │
│                        │           │                 │       │
│                        │           ▼                 │       │
│                        │    ┌──────────────┐         │       │
│                        │    │ order_items  │         │       │
│                        │    │──────────────│         │       │
│                        │    │ id (PK)      │         │       │
│                        │    │ order_id(FK) │─────────┘       │
│                        │    │ product_id   │                 │
│                        │    │ quantity     │                 │
│                        │    │ price        │                 │
│                        │    └──────────────┘                 │
│                        │                                      │
│                        └───────────────┐                     │
│                                        ▼                     │
│                                 ┌──────────────┐             │
│                                 │ addresses    │             │
│                                 │──────────────│             │
│                                 │ id (PK)      │             │
│                                 │ user_id (FK) │             │
│                                 │ street       │             │
│                                 │ city         │             │
│                                 │ country      │             │
│                                 └──────────────┘             │
│                                                               │
└──────────────────────────────────────────────────────────────┘

Table Definition Panel

┌────────────────────────────────────────┐
│ Table: users                           │
├────────────────────────────────────────┤
│ Fields:                                │
│  ✓ id           UUID      PK           │
│  ✓ email        String    UNIQUE       │
│  ✓ full_name    String                 │
│  ✓ password     String                 │
│  ✓ role         Enum      DEFAULT:USER │
│  ✓ created_at   DateTime  DEFAULT:NOW  │
│  ✓ updated_at   DateTime  AUTO_UPDATE  │
│                                        │
│ Indexes:                               │
│  • idx_email (email) UNIQUE            │
│  • idx_created_at (created_at)         │
│                                        │
│ Relationships:                         │
│  → orders (one-to-many)                │
│  → addresses (one-to-many)             │
│                                        │
│ [Add Field] [Add Index] [AI Optimize] │
└────────────────────────────────────────┘

API Integration

Creating an Instance

POST /api/service-instances

{
  "instanceName": "Production Database Schema",
  "serviceId": "nexr-modeler-service-id",
  "servicePlanId": "team-plan-id",
  "subaccountId": "your-subaccount-id",
  "globalAccountId": "your-global-account-id"
}

Creating a Schema Project

POST /api/modeler/projects

{
  "name": "E-commerce Database",
  "description": "Main database schema for e-commerce platform",
  "databaseType": "postgresql",
  "version": "15.0",
  "settings": {
    "namingConvention": "snake_case",
    "timestamps": true,
    "softDelete": true
  }
}

Adding a Table

POST /api/modeler/projects/{projectId}/tables

{
  "name": "users",
  "schema": "public",
  "fields": [
    {
      "name": "id",
      "type": "UUID",
      "primaryKey": true,
      "default": "gen_random_uuid()"
    },
    {
      "name": "email",
      "type": "VARCHAR(255)",
      "unique": true,
      "nullable": false
    },
    {
      "name": "full_name",
      "type": "VARCHAR(255)",
      "nullable": false
    },
    {
      "name": "created_at",
      "type": "TIMESTAMP",
      "default": "NOW()"
    }
  ],
  "indexes": [
    {
      "name": "idx_users_email",
      "fields": ["email"],
      "unique": true
    }
  ]
}

Generating Prisma Schema

POST /api/modeler/projects/{projectId}/export

{
  "format": "prisma",
  "options": {
    "includeRelations": true,
    "generateEnums": true,
    "addComments": true
  }
}

Response - Prisma Schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id        String   @id @default(uuid()) @db.Uuid
  email     String   @unique
  fullName  String   @map("full_name")
  role      UserRole @default(USER)
  createdAt DateTime @default(now()) @map("created_at")
  updatedAt DateTime @updatedAt @map("updated_at")

  orders    Order[]
  addresses Address[]

  @@index([createdAt])
  @@map("users")
}

model Order {
  id          String      @id @default(uuid()) @db.Uuid
  userId      String      @map("user_id") @db.Uuid
  totalAmount Decimal     @map("total_amount")
  status      OrderStatus @default(PENDING)
  createdAt   DateTime    @default(now()) @map("created_at")

  user        User        @relation(fields: [userId], references: [id])
  items       OrderItem[]

  @@index([userId])
  @@map("orders")
}

enum UserRole {
  USER
  ADMIN
  MANAGER
}

enum OrderStatus {
  PENDING
  CONFIRMED
  SHIPPED
  DELIVERED
  CANCELLED
}

Generating Migration Scripts

POST /api/modeler/projects/{projectId}/migrate

{
  "migrationName": "add_users_and_orders",
  "compareWith": "previous_version", // or database connection
  "generateRollback": true
}

Service Plans

Free Plan

Pricing: Free
Features:
- 3 schema projects
- Up to 10 tables per project
- Basic export formats
- Community support

Professional Plan

Pricing: $29/month
Features:
- Unlimited schema projects
- Unlimited tables
- All export formats
- AI-powered optimization
- Migration generator
- Version control
- Priority support

Team Plan

Pricing: $99/month
Features:
- Everything in Professional
- 10 team members
- Real-time collaboration
- Database connections
- Reverse engineering
- Custom templates
- Advanced security

Enterprise Plan

Pricing: Custom
Features:
- Everything in Team
- Unlimited team members
- On-premise deployment
- SSO integration
- Dedicated support
- Custom integrations
- SLA guarantees

Enterprise Features

Schema Version Control

Track all schema changes with Git-like versioning:

Branching: Create schema branches for experimentation
Merging: Merge schema changes from multiple branches
History: Complete audit trail of all changes
Rollback: Revert to previous schema versions
Diffing: Visual comparison between schema versions

Team Collaboration

Work together on database design:

Real-Time Editing: Multiple users edit simultaneously
Comments: Annotate tables and fields with comments
Mentions: Tag team members for review
Approval Workflow: Require approval for schema changes
Role-Based Access: Control who can view/edit schemas

Database Connections

Connect to live databases:

Reverse Engineering: Import existing schemas
Schema Sync: Keep model in sync with database
Live Preview: Test queries against connected database
Data Exploration: Browse database data
Migration Execution: Apply migrations directly

AI-Powered Features

Schema Optimization

Let AI analyze and improve your schema:

POST /api/modeler/projects/{projectId}/analyze

{
  "checks": [
    "normalization",
    "indexes",
    "performance",
    "security",
    "naming_conventions"
  ]
}

Analysis Results

{
  "score": 85,
  "issues": [
    {
      "severity": "warning",
      "type": "missing_index",
      "table": "orders",
      "field": "user_id",
      "message": "Foreign key 'user_id' should have an index",
      "suggestion": "CREATE INDEX idx_orders_user_id ON orders(user_id);"
    },
    {
      "severity": "info",
      "type": "normalization",
      "table": "users",
      "message": "Consider separating 'address' into a separate table",
      "suggestion": "Create an 'addresses' table with one-to-many relationship"
    }
  ],
  "recommendations": [
    "Add composite index on (user_id, created_at) for orders table",
    "Consider partitioning 'orders' table by date",
    "Use ENUM for 'status' field instead of VARCHAR"
  ]
}