Skip to main content

BOSS Platform

Business Operations & Systems Support

Overview​

The BOSS Platform is a comprehensive enterprise workflow management and business process automation system designed to streamline operations across all departments. Built with modern technologies and enterprise-grade architecture, it provides a unified platform for managing tickets, processes, tasks, teams, and business workflows.

What is BOSS?​

BOSS (Business Operations & Systems Support) is a complete business management platform that combines:

  • Process Automation: Visual workflow builder for complex business processes
  • Task Management: Kanban boards, task libraries, and execution tracking
  • Team Collaboration: Hierarchical organization with departments and teams
  • Tool Integration: Built-in tools for email, WhatsApp, data processing, and more
  • Role-Based Access: 5-level hierarchical permission system
  • Real-time Dashboard: Customizable widgets and KPI tracking

Key Features​

🏢 Organization Management​

  • Hierarchical Structure: Organization → Departments → Teams → Users
  • Department Functions: Predefined templates (Sales, HR, Engineering, Operations, etc.)
  • Team Management: Capacity planning, member assignments, performance metrics
  • Multi-team Support: Users can belong to multiple teams
  • Reporting Lines: Clear hierarchy with manager-subordinate relationships

🔐 Advanced RBAC System​

  • 5-Level Role Hierarchy:
    • SUPER_ADMIN (Level 100): System-wide access
    • CEO (Level 90): Organization-wide access
    • DEPARTMENT_HEAD (Level 70): Department access
    • MANAGER (Level 50): Team access
    • INDIVIDUAL_CONTRIBUTOR (Level 30): Own resources
  • Granular Permissions: Resource-based with specific actions (create, read, update, delete)
  • Scoped Access: Global, Organization, Department, Team, and Resource scopes
  • Visibility Controls: Users can only see resources within their hierarchy

Process Builder & Workflows​

  • Visual Designer: Drag-and-drop workflow creation with ReactFlow
  • DAG Validation: Ensures process flows are acyclic
  • Custom Fields: Dynamic fields per process type
  • Task Definitions: Reusable task templates with tool bindings
  • Phase Management: Multi-phase processes with automatic transitions
  • Field Mapping: Smart mapping of ticket fields to task parameters

🎯 Ticket & Task System​

  • Ticket Management: Full lifecycle from creation to completion
  • Kanban Boards: Phase-based visual task organization
  • Task Workspace: Integrated environment with tool execution
  • Bulk Operations: Create and manage multiple tickets
  • Custom Fields: Flexible data model per process type
  • Activity Tracking: Complete audit trail of all changes

🛠️ Tool Execution Framework​

  • Built-in Tools:
    • Email Tool: SMTP-based email sending with templates
    • WhatsApp Tool: Gallabox integration for messaging
    • Apollo.io: Lead generation and enrichment
    • CSV Processor: Data import and processing
    • Deep Research: Web research automation
    • Plivo Calling: Voice call integration (in development)
  • Tool Templates: Smart field mapping suggestions
  • Permission System: Fine-grained tool access control
  • Output Processing: Structured visualization of tool results

📱 Communication Integrations​

  • WhatsApp Integration (Gallabox):
    • Template messaging
    • Session management
    • Message tracking (sent, delivered, read)
    • Cost tracking
    • Free entry point support (ads, CTAs)
  • Email Service:
    • SMTP integration
    • Template library with presets
    • Variable substitution
    • Attachment support

📝 Blog & CMS System​

  • Rich Content: Markdown-based blog posts
  • Engagement: Likes, bookmarks, comments with nested replies
  • SEO Optimization: Meta tags, slugs, featured images
  • Analytics: View counts, interaction tracking
  • Access Control: Draft, published, archived states

📊 Universal Dashboard​

  • Drag-and-Drop: Customizable widget layouts
  • 20+ Widget Types: KPIs, charts, task lists, process flows
  • Real-time Updates: Live data refresh
  • Role-Based Views: Different dashboards per role
  • Responsive Design: Works on all screen sizes

Functional Coverage Snapshot​

The backend already supports far more than process + ticket CRUD. Use this at-a-glance map before opening new tickets:

  • Org & Access Fabric – Five-tier RBAC, hierarchical visibility helpers, and complete org/department/team CRUD live under pkg/rbac and internal/service/*. Platform APIs automatically scope every request based on the authenticated user’s hierarchy.
  • Workflow → Ticket → Task Pipeline – internal/service/process_service.go, ticket_service.go, and task_service.go keep process definitions, ticket lifecycles, and rich task workspaces (dependencies, deliverables, threaded feedback, SLA/evaluation metadata) in sync.
  • Tool & Communication Layer – The tool executor (internal/tools) powers email, WhatsApp, Apollo, CSV, campaign builder, deep research, Google Meet scheduling, and Plivo calling. Templates/presets, permission checks, normalized outputs, and per-run cost capture are first-class features.
  • Agents & Automation – Runtime agents (internal/service/runtime_agent_service.go + agent_service.go), the sales outreach automation service, summarization/task-monitoring dispatchers, and the Agent Bridge enable closed-loop automations with secure webhooks and run telemetry.
  • Campaigns, Contacts & Scheduling – Public contact APIs, a campaign builder with short links + QR codes, campaign traffic tracking, scheduler services, and Google Calendar OAuth already exist for growth and sales workflows.
  • Analytics & Intelligence – Cost dashboards, rate management, tool output normalization, call/WhatsApp/email summaries, and knowledge artefacts (blog, summary templates) ensure every interaction is aggregated and searchable.

See the dedicated Platform Capabilities page for deeper descriptions and file-level references.

Technology Stack​

Frontend​

  • Framework: Next.js 15.5 with React 19
  • Language: TypeScript 5
  • State Management: Zustand with persistence
  • UI Components: Radix UI primitives + Tailwind CSS
  • Data Visualization: Recharts, ReactFlow for process builder
  • Forms: React Hook Form with Zod validation
  • HTTP Client: Axios with interceptors
  • Real-time: WebSocket client for live updates

Backend​

  • Language: Go 1.21+
  • Web Framework: Gin for HTTP routing
  • Database: MongoDB 6.0+ (official Go driver)
  • Caching: Redis 7.0+ for sessions and data
  • Authentication: JWT (RS256) + OTP support
  • Logging: Uber Zap structured logging
  • Validation: Go validator v10

Database & Infrastructure​

  • Primary Database: MongoDB Atlas
    • Flexible document model
    • Hierarchical data support
    • Full-text search
    • Aggregation pipelines
  • Cache Layer: Azure Redis Cache
    • Session management
    • OTP storage
    • API response caching
  • Deployment: Docker containers on Azure
  • Monitoring: Azure Application Insights
  • CI/CD: GitHub Actions

Quick Start​

# Clone the repository
git clone https://github.com/your-org/boss-monorepo.git
cd boss-monorepo

# Backend Setup (Go)
cd apps/backend
cp .env.example .env
# Edit .env with your MongoDB and Redis credentials
go mod download
go run cmd/server/main.go

# Frontend Setup (Next.js)
cd apps/web
npm install
cp .env.local.example .env.local
# Edit .env.local with API URL
npm run dev

# Documentation Site
cd apps/docs
npm install
npm run start

Project Structure​

boss-monorepo/
├── apps/
│   ├── backend/              # Go REST API
│   │   ├── cmd/server/       # Main application
│   │   ├── internal/
│   │   │   ├── api/         # HTTP handlers & routes
│   │   │   ├── models/      # Data models
│   │   │   ├── repository/  # Database layer
│   │   │   ├── service/     # Business logic
│   │   │   ├── middleware/  # Auth, RBAC, Audit
│   │   │   └── tools/       # Tool execution framework
│   │   └── pkg/            # Shared packages
│   │
│   ├── web/                 # Next.js Frontend
│   │   ├── src/
│   │   │   ├── app/        # App router pages
│   │   │   ├── components/ # React components
│   │   │   ├── services/   # API client services
│   │   │   ├── store/      # Zustand state stores
│   │   │   └── lib/        # Utilities
│   │   └── public/         # Static assets
│   │
│   ├── docs/               # Documentation (Docusaurus)
│   └── agents/             # Python AI agents (LangChain)
│
└── postman/                # API collection

Core Concepts​

Process-Driven Workflow​

  1. Create Process: Design workflow with visual builder
  2. Define Tasks: Add task definitions with tool bindings
  3. Create Tickets: Instantiate process with custom data
  4. Execute Tasks: Run tasks with integrated tools
  5. Track Progress: Monitor through dashboards and reports

Hierarchical Organization​

Organization
 └── Departments (Sales, Engineering, HR, etc.)
      └── Teams (Sales Team 1, Backend Team, etc.)
           └── Users (Employees with roles)

Role-Based Permissions​

Permission Check Flow:
1. User Role Level (100, 90, 70, 50, 30)
2. Resource Permission (create, read, update, delete)
3. Scope Validation (Global, Org, Dept, Team, Resource)
4. Hierarchical Access (can access subordinate resources)

Use Cases​

Sales CRM​

  • Lead qualification workflows
  • Discovery and demo scheduling
  • Proposal generation with Apollo.io data
  • Email and WhatsApp outreach
  • Deal tracking and reporting

Customer Success​

  • Onboarding automation
  • Training schedule management
  • Adoption tracking
  • Health score monitoring
  • Renewal workflows

HR Operations​

  • Employee onboarding
  • Leave management
  • Performance review processes
  • Recruitment workflows
  • Document management

Operations​

  • Ticket routing and assignment
  • SLA tracking
  • Escalation workflows
  • Resource allocation
  • Performance analytics

Security & Compliance​

  • Authentication: JWT tokens with refresh mechanism + OTP support
  • Authorization: 5-level hierarchical RBAC
  • Data Security: Password hashing (bcrypt), encrypted tokens
  • CSRF Protection: Token-based validation
  • Audit Logging: All mutations logged with user context
  • Access Control: Row-level security based on hierarchy
  • Session Management: Redis-based distributed sessions

Next Steps​

Support & Community​

  • GitHub: boss-monorepo
  • Issues: Report bugs and request features
  • Documentation: You're here! 📚
  • API Collection: Postman collection in /postman

BOSS Platform - Powering efficient business operations with intelligent automation.