Admin Console & System Management

Insiders

System Admin

Every Karrio Insiders project comes with a comprehensive admin console, providing centralized system management, user administration, platform configuration, and monitoring tools for enterprise deployments.

Features

System Administration

You don’t have to manage your Karrio platform manually. Our admin console provides complete oversight of users, organizations, system settings, and platform health from a single interface.

Admin Console Dashboard

Screenshot: Admin dashboard with system metrics, user management, and organization overview

User Management

Complete user lifecycle management including creation, role assignment, activity monitoring, and security controls.

Organization Administration

Manage organizations across your platform with settings control, user allocation, and resource monitoring.

Platform Configuration

System-wide settings management including security policies, feature flags, and integration configurations.

Monitoring & Analytics

Real-time platform health monitoring, usage analytics, and performance metrics with alerting capabilities.

Security Management

Advanced security controls including access policies, audit logs, and compliance monitoring.

Additional features

Karrio extends admin console with customizable dashboards and automated monitoring.
Every admin action includes detailed audit trails and approval workflows.
Karrio manages role-based access controls and permission inheritance.
Support for custom admin plugins and third-party integrations.

Data Flow

Admin Console Architecture

API Reference

GraphQL API

Admin Authentication

1mutation AdminLogin($input: AdminLoginInput!) {
2  adminLogin(input: $input) {
3    token
4    user {
5      id
6      email
7      isStaff
8      isSuperuser
9      permissions
10    }
11    errors {
12      field
13      messages
14    }
15  }
16}

Variables:

1{
2  "input": {
3    "email": "admin@company.com",
4    "password": "admin_password"
5  }
6}

Response:

1{
2  "data": {
3    "adminLogin": {
4      "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
5      "user": {
6        "id": "admin_1234567890",
7        "email": "admin@company.com",
8        "isStaff": true,
9        "isSuperuser": true,
10        "permissions": [
11          "admin.users",
12          "admin.organizations",
13          "admin.system",
14          "admin.monitoring"
15        ]
16      },
17      "errors": []
18    }
19  }
20}

User Management

1query GetUsers($filter: UserFilter, $pagination: PaginationInput) {
2  users(filter: $filter, first: $pagination.first, after: $pagination.after) {
3    edges {
4      node {
5        id
6        email
7        firstName
8        lastName
9        isActive
10        dateJoined
11        lastLogin
12        organizations {
13          id
14          name
15          role
16        }
17      }
18    }
19    pageInfo {
20      hasNextPage
21      hasPreviousPage
22      startCursor
23      endCursor
24    }
25    totalCount
26  }
27}

Variables:

1{
2  "filter": {
3    "isActive": true,
4    "organizationId": "org_1234567890"
5  },
6  "pagination": {
7    "first": 20,
8    "after": null
9  }
10}

Response:

1{
2  "data": {
3    "users": {
4      "edges": [
5        {
6          "node": {
7            "id": "usr_1234567890",
8            "email": "user@example.com",
9            "firstName": "John",
10            "lastName": "Doe",
11            "isActive": true,
12            "dateJoined": "2024-01-15T10:30:00Z",
13            "lastLogin": "2024-01-20T14:22:00Z",
14            "organizations": [
15              {
16                "id": "org_1234567890",
17                "name": "Acme Corp",
18                "role": "admin"
19              }
20            ]
21          }
22        }
23      ],
24      "pageInfo": {
25        "hasNextPage": true,
26        "hasPreviousPage": false,
27        "startCursor": "cursor123",
28        "endCursor": "cursor456"
29      },
30      "totalCount": 150
31    }
32  }
33}

Create User

1mutation CreateUser($input: CreateUserInput!) {
2  createUser(input: $input) {
3    user {
4      id
5      email
6      firstName
7      lastName
8      isActive
9    }
10    errors {
11      field
12      messages
13    }
14  }
15}

Variables:

1{
2  "input": {
3    "email": "newuser@example.com",
4    "firstName": "Jane",
5    "lastName": "Smith",
6    "password": "secure_password",
7    "isActive": true,
8    "organizationId": "org_1234567890",
9    "role": "member"
10  }
11}

Response:

1{
2  "data": {
3    "createUser": {
4      "user": {
5        "id": "usr_1234567891",
6        "email": "newuser@example.com",
7        "firstName": "Jane",
8        "lastName": "Smith",
9        "isActive": true
10      },
11      "errors": []
12    }
13  }
14}

Organization Management

1query GetOrganizations($filter: OrganizationFilter) {
2  organizations(filter: $filter) {
3    edges {
4      node {
5        id
6        name
7        slug
8        isActive
9        createdAt
10        userCount
11        shipmentCount
12        settings {
13          maxUsers
14          maxShipmentsPerMonth
15          allowedCarriers
16          features
17        }
18      }
19    }
20  }
21}

Variables:

1{
2  "filter": {
3    "isActive": true,
4    "createdAfter": "2024-01-01T00:00:00Z"
5  }
6}

Response:

1{
2  "data": {
3    "organizations": {
4      "edges": [
5        {
6          "node": {
7            "id": "org_1234567890",
8            "name": "Acme Corporation",
9            "slug": "acme-corp",
10            "isActive": true,
11            "createdAt": "2024-01-15T10:30:00Z",
12            "userCount": 25,
13            "shipmentCount": 1500,
14            "settings": {
15              "maxUsers": 50,
16              "maxShipmentsPerMonth": 10000,
17              "allowedCarriers": ["fedex", "ups", "usps"],
18              "features": ["tracking", "webhooks", "batch_processing"]
19            }
20          }
21        }
22      ]
23    }
24  }
25}

REST API

System Configuration

1curl -X GET "https://api.karrio.io/admin/system/config" \
2  -H "Authorization: Token ADMIN_API_KEY"

Response:

1{
2  "config": {
3    "ALLOW_SIGNUP": false,
4    "ALLOW_ADMIN_APPROVED_SIGNUP": true,
5    "MULTI_ORGANIZATIONS": true,
6    "ORDERS_MANAGEMENT": true,
7    "AUDIT_LOGGING": true,
8    "WEBHOOK_NOTIFICATIONS": true,
9    "RATE_LIMITING": {
10      "enabled": true,
11      "requests_per_minute": 1000
12    },
13    "SECURITY": {
14      "password_min_length": 8,
15      "session_timeout": 3600,
16      "require_2fa": false
17    },
18    "FEATURES": {
19      "batch_processing": true,
20      "document_generation": true,
21      "advanced_tracking": true
22    }
23  }
24}

Update System Settings

1curl -X POST "https://api.karrio.io/admin/system/config" \
2  -H "Authorization: Token ADMIN_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "ALLOW_SIGNUP": false,
6    "ALLOW_ADMIN_APPROVED_SIGNUP": true,
7    "MULTI_ORGANIZATIONS": true,
8    "SECURITY": {
9      "password_min_length": 12,
10      "session_timeout": 7200,
11      "require_2fa": true
12    }
13  }'

Response:

1{
2  "success": true,
3  "updated_settings": [
4    "SECURITY.password_min_length",
5    "SECURITY.session_timeout",
6    "SECURITY.require_2fa"
7  ],
8  "message": "System configuration updated successfully"
9}

Platform Health Status

1curl -X GET "https://api.karrio.io/admin/health" \
2  -H "Authorization: Token ADMIN_API_KEY"

Response:

1{
2  "status": "healthy",
3  "timestamp": "2024-01-15T10:30:00Z",
4  "services": {
5    "database": {
6      "status": "healthy",
7      "response_time": 15,
8      "connections": 25
9    },
10    "redis": {
11      "status": "healthy",
12      "response_time": 2,
13      "memory_usage": "45%"
14    },
15    "carrier_apis": {
16      "status": "healthy",
17      "ups": "operational",
18      "fedex": "operational",
19      "usps": "degraded"
20    }
21  },
22  "metrics": {
23    "active_users": 150,
24    "organizations": 12,
25    "shipments_today": 450,
26    "api_requests_per_minute": 750
27  }
28}

Admin Features

User Administration

Complete user lifecycle management:

1class UserAdmin {
2  constructor(adminToken) {
3    this.adminToken = adminToken;
4  }
5
6  async createUser(userData) {
7    const query = `
8      mutation CreateUser($input: CreateUserInput!) {
9        createUser(input: $input) {
10          user {
11            id
12            email
13            firstName
14            lastName
15            isActive
16          }
17          errors {
18            field
19            messages
20          }
21        }
22      }
23    `;
24
25    const response = await fetch("/graphql", {
26      method: "POST",
27      headers: {
28        Authorization: `Token ${this.adminToken}`,
29        "Content-Type": "application/json",
30      },
31      body: JSON.stringify({
32        query,
33        variables: { input: userData },
34      }),
35    });
36
37    return await response.json();
38  }
39
40  async updateUserRole(userId, organizationId, role) {
41    const query = `
42      mutation UpdateUserRole($input: UpdateUserRoleInput!) {
43        updateUserRole(input: $input) {
44          success
45          errors {
46            field
47            messages
48          }
49        }
50      }
51    `;
52
53    return await this.graphqlRequest(query, {
54      input: { userId, organizationId, role },
55    });
56  }
57
58  async getUserActivity(userId, timeRange = "7d") {
59    const query = `
60      query GetUserActivity($userId: ID!, $timeRange: String!) {
61        userActivity(userId: $userId, timeRange: $timeRange) {
62          activities {
63            timestamp
64            action
65            resource
66            details
67            ipAddress
68          }
69          summary {
70            totalActions
71            lastSeen
72            mostActiveHour
73          }
74        }
75      }
76    `;
77
78    return await this.graphqlRequest(query, { userId, timeRange });
79  }
80}

Organization Management

Comprehensive organization administration:

1class OrganizationAdmin {
2  constructor(adminToken) {
3    this.adminToken = adminToken;
4  }
5
6  async createOrganization(orgData) {
7    const query = `
8      mutation CreateOrganization($input: CreateOrganizationInput!) {
9        createOrganization(input: $input) {
10          organization {
11            id
12            name
13            slug
14            settings
15          }
16          errors {
17            field
18            messages
19          }
20        }
21      }
22    `;
23
24    return await this.graphqlRequest(query, { input: orgData });
25  }
26
27  async updateOrganizationSettings(orgId, settings) {
28    const query = `
29      mutation UpdateOrganizationSettings($input: UpdateOrganizationSettingsInput!) {
30        updateOrganizationSettings(input: $input) {
31          organization {
32            id
33            settings
34          }
35          errors {
36            field
37            messages
38          }
39        }
40      }
41    `;
42
43    return await this.graphqlRequest(query, {
44      input: { organizationId: orgId, settings },
45    });
46  }
47
48  async getOrganizationMetrics(orgId, timeRange = "30d") {
49    const query = `
50      query GetOrganizationMetrics($orgId: ID!, $timeRange: String!) {
51        organizationMetrics(organizationId: $orgId, timeRange: $timeRange) {
52          shipments {
53            total
54            successful
55            failed
56            trend
57          }
58          users {
59            active
60            inactive
61            newSignups
62          }
63          costs {
64            totalShipping
65            averagePerShipment
66            topCarriers
67          }
68        }
69      }
70    `;
71
72    return await this.graphqlRequest(query, { orgId, timeRange });
73  }
74}

System Monitoring

Platform health and performance monitoring:

1class SystemMonitor {
2  constructor(adminToken) {
3    this.adminToken = adminToken;
4    this.alertThresholds = {
5      apiResponseTime: 1000, // ms
6      errorRate: 0.01, // 1%
7      activeConnections: 1000,
8    };
9  }
10
11  async getSystemHealth() {
12    const response = await fetch("/admin/health", {
13      headers: {
14        Authorization: `Token ${this.adminToken}`,
15      },
16    });
17
18    return await response.json();
19  }
20
21  async getPerformanceMetrics(timeRange = "24h") {
22    const response = await fetch(`/admin/metrics?range=${timeRange}`, {
23      headers: {
24        Authorization: `Token ${this.adminToken}`,
25      },
26    });
27
28    return await response.json();
29  }
30
31  async checkAlerts() {
32    const health = await this.getSystemHealth();
33    const alerts = [];
34
35    // Check API response times
36    if (
37      health.services.database.response_time >
38      this.alertThresholds.apiResponseTime
39    ) {
40      alerts.push({
41        type: "performance",
42        severity: "warning",
43        message: "Database response time is elevated",
44        value: health.services.database.response_time,
45      });
46    }
47
48    // Check carrier API status
49    Object.entries(health.services.carrier_apis).forEach(
50      ([carrier, status]) => {
51        if (status === "degraded" || status === "down") {
52          alerts.push({
53            type: "service",
54            severity: status === "down" ? "critical" : "warning",
55            message: `${carrier.toUpperCase()} API is ${status}`,
56            carrier,
57          });
58        }
59      },
60    );
61
62    return alerts;
63  }
64
65  async generateHealthReport() {
66    const health = await this.getSystemHealth();
67    const metrics = await this.getPerformanceMetrics();
68    const alerts = await this.checkAlerts();
69
70    return {
71      timestamp: new Date().toISOString(),
72      overallStatus: health.status,
73      services: health.services,
74      platformMetrics: health.metrics,
75      performanceMetrics: metrics,
76      activeAlerts: alerts,
77      recommendations: this.generateRecommendations(health, metrics, alerts),
78    };
79  }
80
81  generateRecommendations(health, metrics, alerts) {
82    const recommendations = [];
83
84    if (alerts.some((alert) => alert.type === "performance")) {
85      recommendations.push({
86        category: "performance",
87        priority: "high",
88        message: "Consider scaling database resources or optimizing queries",
89      });
90    }
91
92    if (metrics.api_requests_per_minute > 800) {
93      recommendations.push({
94        category: "capacity",
95        priority: "medium",
96        message:
97          "API usage approaching limits, consider rate limiting adjustments",
98      });
99    }
100
101    return recommendations;
102  }
103}

Security Features

Access Control

Role-based access control with fine-grained permissions:

1const adminRoles = {
2  superAdmin: {
3    permissions: [
4      "admin.users.create",
5      "admin.users.update",
6      "admin.users.delete",
7      "admin.organizations.create",
8      "admin.organizations.update",
9      "admin.organizations.delete",
10      "admin.system.config",
11      "admin.monitoring.view",
12    ],
13  },
14  organizationAdmin: {
15    permissions: [
16      "admin.users.create",
17      "admin.users.update",
18      "admin.organizations.view",
19      "admin.organizations.update",
20    ],
21    scope: "organization",
22  },
23  supportAdmin: {
24    permissions: [
25      "admin.users.view",
26      "admin.organizations.view",
27      "admin.monitoring.view",
28    ],
29    readonly: true,
30  },
31};
32
33class AccessControl {
34  constructor(userRole, organizationId = null) {
35    this.userRole = userRole;
36    this.organizationId = organizationId;
37  }
38
39  hasPermission(permission, resourceId = null) {
40    const roleConfig = adminRoles[this.userRole];
41
42    if (!roleConfig || !roleConfig.permissions.includes(permission)) {
43      return false;
44    }
45
46    // Check scope restrictions
47    if (roleConfig.scope === "organization" && resourceId) {
48      return this.organizationId === resourceId;
49    }
50
51    return true;
52  }
53
54  canAccessResource(resourceType, resourceId) {
55    const basePermission = `admin.${resourceType}.view`;
56    return this.hasPermission(basePermission, resourceId);
57  }
58}

Audit Logging

Comprehensive audit trail for all admin actions:

1class AuditLogger {
2  static async logAction(action, adminUser, details = {}) {
3    const auditEntry = {
4      timestamp: new Date().toISOString(),
5      action,
6      adminUserId: adminUser.id,
7      adminUserEmail: adminUser.email,
8      ipAddress: details.ipAddress,
9      userAgent: details.userAgent,
10      resourceType: details.resourceType,
11      resourceId: details.resourceId,
12      changes: details.changes,
13      success: details.success !== false,
14    };
15
16    // Store in audit log
17    await this.storeAuditEntry(auditEntry);
18
19    // Send to monitoring system
20    if (this.isHighRiskAction(action)) {
21      await this.alertSecurityTeam(auditEntry);
22    }
23  }
24
25  static isHighRiskAction(action) {
26    const highRiskActions = [
27      "user.delete",
28      "organization.delete",
29      "system.config_change",
30      "admin.privilege_escalation",
31    ];
32
33    return highRiskActions.includes(action);
34  }
35
36  static async getAuditTrail(filters = {}) {
37    const query = `
38      query GetAuditTrail($filter: AuditFilter!) {
39        auditTrail(filter: $filter) {
40          entries {
41            timestamp
42            action
43            adminUser {
44              id
45              email
46            }
47            resourceType
48            resourceId
49            changes
50            success
51          }
52        }
53      }
54    `;
55
56    return await this.graphqlRequest(query, { filter: filters });
57  }
58}

Use Cases

Enterprise Platform Management

Perfect for large-scale Karrio deployments:

Multi-Organization Management: Centralized control of multiple business units
User Lifecycle Management: Automated user provisioning and deprovisioning
Compliance Monitoring: Audit trails and compliance reporting
Performance Optimization: System monitoring and capacity planning

SaaS Platform Operations

Designed for Karrio-based SaaS platforms:

Customer Organization Management: Self-service and admin-managed customer accounts
Feature Flag Management: Controlled rollout of new features
Usage Monitoring: Track customer usage and billing metrics
Support Operations: Customer support tools and account management

Managed Service Providers

Built for MSPs offering shipping services:

Client Management: Manage multiple client organizations
Service Level Monitoring: Track SLA compliance and performance
Resource Allocation: Manage capacity and resource distribution
Billing Integration: Usage tracking for billing purposes

Getting Started

Ready to manage your Karrio platform with the admin console? Follow these steps:

Set up admin authentication with appropriate role assignments
Configure system settings for your deployment requirements
Implement monitoring and alerting for platform health
Establish audit procedures for compliance and security

Next Steps

Learn about user management for detailed user administration
Explore multi-organizations for organization management
Set up webhooks for system event notifications
Configure api logs for detailed API monitoring

Product Guides

Control Plane

Developer Tools

Admin Console & System Management

Features

System Administration

User Management

Organization Administration

Platform Configuration

Monitoring & Analytics

Security Management

Additional features

Data Flow

Admin Console Architecture

API Reference

GraphQL API

Admin Authentication

User Management

Create User

Organization Management

REST API

System Configuration

Update System Settings

Platform Health Status

Admin Features

User Administration

Organization Management

System Monitoring

Security Features

Access Control

Audit Logging

Use Cases

Enterprise Platform Management

SaaS Platform Operations

Managed Service Providers

Getting Started

Next Steps