Professional Services Automation for the Modern Agency

MovaLab is a cloud-based platform that consolidates agency operations into a single, intelligent system. Built for marketing agencies, creative studios, and consulting firms with 5-50 employees who are tired of juggling Monday.com, Notion, Harvest, Float, and spreadsheets just to answer "do we have capacity for this project?"

Originally developed for a student-run marketing agency managing 11 client accounts across 8 departments with 60+ members, MovaLab replaces what used to require Basecamp, Monday.com, Notion, MS Planner, and Slack with a single unified system.

Try the Live Demo | Visit movalab.dev

Professional services organizations struggle with:

• Tool fragmentation — Projects in Monday.com, time in Toggl, communication in Slack, capacity in spreadsheets
• Lack of visibility — Can't answer "who's overloaded?" or "do we have capacity?" without hours of investigation
• Organizational chaos — Team rotations, unclear accountability, tribal knowledge lost when people leave
• Client communication — "Any updates?" emails because clients have no visibility into progress
• Ignored SOPs — 30-page PDFs that no one reads, informal workflows, inconsistent quality

The result? Burnout, missed deadlines, over-commitment, and margins that erode with every project.

MovaLab replaces your fragmented tool stack with one unified platform:

One platform. One source of truth. 40-60% reduction in software costs.

• Proportional allocation — Users on 3 accounts split their 40 hrs/week capacity proportionally (13.3 hrs each)
• Real-time utilization — Track individual, department, and organization-wide capacity
• Multi-level analytics — Individual → Department → Account → Organization views
• Prevents over-commitment — Know if you can take new work before saying yes

• Drag-and-drop workflow builder — Transform SOPs into visual, enforceable workflows
• Node types — Department handoffs, role assignments, client approvals, conditional branches
• Complete audit trail — Track every transition, handoff, and approval
• Guardrails, not handcuffs — Structure that guides without being rigid

• Clock in/out — Start timer, work, allocate hours across tasks when done
• Manual entry — Log hours directly on specific tasks
• Auto clock-out — Sessions auto-close after 16 hours (prevents forgotten sessions)
• User dashboard — View, filter, and analyze logged time with charts and 14-day edit window

• ~40 consolidated permissions across 15 categories (reduced from 136 via RBAC refactoring)
• Context-aware access — Permissions adapt based on project assignments and account management
• Row Level Security — Data access controlled at PostgreSQL level, not just application logic
• Hierarchical reporting — Clear chains of accountability

• Kanban boards — Drag-and-drop task management (To Do → In Progress → Review → Done)
• Gantt charts — Timeline visualization with dependencies and critical paths
• Table views — Sortable, filterable lists for bulk updates
• Workflow views — Track projects through custom approval workflows
• Analytics dashboards — Performance metrics, resource allocation, project health

• Project visibility — Clients see real-time progress without pestering your team
• Built-in approvals — Review, approve, or request revisions directly
• Feedback collection — Post-project satisfaction scoring and insights
• Secure isolation — Clients see only their own projects (RLS enforced)

Modern & Scalable

• Next.js 15 (App Router) + React Server Components
• TypeScript for type safety
• Supabase (PostgreSQL + Row Level Security)
• Tailwind CSS + shadcn/ui
• Recharts for analytics

Security-First

• Row Level Security on every table
• ~40 consolidated permissions (MANAGE pattern)
• Rate limiting (Upstash Redis)
• Input validation (Zod schemas)
• Audit logging for critical changes
• HTTP-only cookies, security headers

✨ Zero-configuration Docker setup! No cloud accounts needed. Everything runs locally.

📚 First time? See our Complete Setup Guide for detailed instructions.

Before you begin, ensure you have:

• ✅ Node.js 18.0+ (Download)
• ✅ Docker Desktop (Download) - Must be running
• ✅ Docker Hub Account (Recommended) - Create free account to avoid rate limits
• ✅ Windows users: Git Bash (included with Git for Windows) or WSL2
• ⏱️ 5 minutes setup time

💡 Important: Authenticate with Docker Hub to avoid rate limit errors:

docker login

This increases pull limits from 100 to 200 per 6 hours and prevents "Rate exceeded" errors during setup.

macOS / Linux:

git clone https://github.com/itigges22/movalab.git
cd movalab
./scripts/first-time-setup.sh

Windows - Choose Your Terminal:

# In Git Bash terminal:
git clone https://github.com/itigges22/movalab.git
cd movalab
./scripts/first-time-setup.sh

REM In Command Prompt:
git clone https://github.com/itigges22/movalab.git
cd movalab
scripts\first-time-setup.bat

# In PowerShell:
git clone https://github.com/itigges22/movalab.git
cd movalab
scripts\first-time-setup.bat

💡 Windows Tip: All three terminals work! Use whichever you're comfortable with. The .bat file automatically finds Git Bash and runs the setup.

That's it! The script automatically:

• ✅ Checks all prerequisites (Node, Docker, Supabase CLI)
• ✅ Installs dependencies
• ✅ Starts local Supabase (PostgreSQL + Auth + Storage + Studio)
• ✅ Applies database migrations (42+ tables with RLS policies)
• ✅ Loads seed data (8 test users, 3 accounts, 6 projects, 20 tasks)
• ✅ Runs health checks and verifies everything works

Setup Flow:

1. Clone repo → 2. Run script → 3. Script validates prerequisites →
4. Starts Docker → 5. Runs migrations → 6. Creates test data →
7. Health check ✅ → 8. Ready to code! 🚀

npm run dev              # Start Next.js dev server

Open http://localhost:3000 and login:

• Email: superadmin@test.local
• Password: Test1234!

Having trouble? We've got you covered:

• 📖 Detailed Setup Guide - Step-by-step with screenshots
• 🔧 Troubleshooting Guide - Common issues and solutions
• 🔄 Environment Switching - Switch between local Docker and cloud Supabase
• 💬 Discord Community - Get help from other users

Quick fixes:

docker login            # Authenticate to avoid rate limits (do this first!)
npm run docker:health   # Check if everything is working
npm run docker:reset    # Reset database if something went wrong

Common Issues:

# Authenticate with Docker Hub (increases limit to 200/6hrs)
docker login

# Then restart the setup
npx supabase stop
./scripts/first-time-setup.sh

scripts\first-time-setup.bat

./scripts/first-time-setup.sh

All test users have password: Test1234!

npm run docker:start      # Start Supabase services
npm run docker:stop       # Stop Supabase (preserves data)
npm run docker:reset      # Reset database and re-run migrations
npm run docker:seed       # Reset database + create seed users
npm run docker:studio     # Open Supabase Studio (database UI)
npm run docker:health     # Verify setup

• App: http://localhost:3000
• Supabase Studio: http://localhost:54323 (database UI)
• API: http://localhost:54321
• PostgreSQL: localhost:54322

For deploying to production with cloud Supabase:

• Node.js 18.0+
• Supabase account (free tier works)
• Vercel/Netlify account (optional, for hosting)

1. Clone and Install

   git clone https://github.com/itigges22/movalab.git
   cd movalab
   npm install

2. Create Supabase Project

   • Go to supabase.com
   • Create new project
   • Note your project URL and publishable key

3. Pull Database Schema

   supabase link --project-ref your-project-ref
   supabase db pull

4. Environment Configuration

   Create .env.local:

   # Supabase (Required)
   NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
   NEXT_PUBLIC_SUPABASE_PUBLISHABLE_DEFAULT_KEY=your-publishable-key
   
   # Rate Limiting (Optional - Production Recommended)
   UPSTASH_REDIS_REST_URL=https://your-redis.upstash.io
   UPSTASH_REDIS_REST_TOKEN=your-token
   ENABLE_RATE_LIMIT=true

5. Push Migrations

   supabase db push

6. Launch

   npm run dev

   Open http://localhost:3000

1. Create Superadmin — Sign up, visit /superadmin-setup to grant yourself admin privileges
2. Build Organization — Create departments and roles via Admin → Roles
3. Invite Team — Members sign up, you approve via Admin → Pending Users
4. Set Capacity — Users set weekly availability in their profile
5. Create Accounts — Add client accounts and start managing projects

MovaLab/
├── app/                    # Next.js App Router
│   ├── accounts/          # Client account management
│   ├── projects/          # Project detail pages
│   ├── capacity/          # Capacity planning
│   ├── analytics/         # Analytics & reporting
│   ├── admin/             # Admin pages
│   ├── time-entries/      # User time tracking dashboard
│   └── api/               # API routes
├── components/            # React components
│   ├── ui/               # shadcn/ui base components
│   ├── kanban-*.tsx      # Kanban boards
│   ├── gantt-chart.tsx   # Gantt visualization
│   ├── capacity-*.tsx    # Capacity planning
│   └── workflow-*.tsx    # Workflow builder
├── lib/                   # Business logic & utilities
│   ├── *-service.ts      # Service layer (encapsulates business logic)
│   ├── permissions.ts    # ~40 permission definitions
│   ├── rbac.ts           # Permission checking logic
│   └── supabase-*.ts     # Supabase client configs
├── types/                 # TypeScript definitions
└── docs/                  # Documentation
    ├── architecture/FEATURELIST.md
    └── security/SECURITY.md

MovaLab Advantage: Purpose-built for professional services with integrated capacity planning, sophisticated permissions, and real-time visibility across all work.

Total team capacity proportionally split across assigned accounts. Prevents over-counting when people work on multiple clients.

Future commitments based on task estimates. Shows if you're over-committing before work begins.

Real logged time — the ground truth of work performed. What you bill and what actually happened.

(Actual ÷ Available) × 100

• 60-80% — Healthy with buffer
• 80-95% — High productivity
• 95-110% — Risk of burnout
• >110% — Critical, redistribute immediately

MovaLab is purpose-built for agencies where:

• Teams wear multiple hats across several clients
• Capacity is tight and over-commitment kills margins
• Turnover means knowledge walks out the door
• Enterprise tools are overkill (and overpriced)
• You need structure without bureaucracy

Agency-Friendly Features:

• Single source of truth across all client work
• Proportional capacity planning that actually works
• Workflows that enforce quality without slowing you down
• Client portal that eliminates status update emails
• Enterprise-grade security at SMB-friendly pricing

Analytics & Insights

• Project health scoring and risk indicators
• Workflow analytics (completion times, bottleneck identification)
• Team wellbeing dashboard for leadership
• Enhanced capacity forecasting

Client & Account Enhancements

• Full client dashboard with project visibility
• External data source integrations (social media analytics per account)
• Strategic plans tied to accounts and projects
• Client feedback improvements

Revenue & Business Operations

• Service offerings library (tied to workflow templates)
• Proposals and estimates
• Bill of materials / project budgeting
• QuickBooks and/or Stripe integration for revenue tracking

Collaboration Analytics

• Network visualizations (who collaborates with whom)
• Department collaboration mapping
• Cross-account team insights

CRM Functions

• New client outreach tracking
• Pipeline management for prospects
• Lead-to-account conversion

Platform Maturity

• Executive analytics dashboard / leadership intelligence hub
• Full mobile compatibility
• Performance recognition system (achievements, badges, tiers)
• Advanced reporting and custom dashboards

Roadmap priorities may shift based on user feedback and design partner needs.

Contributions welcome! See CONTRIBUTING.md for guidelines.

MovaLab was originally developed in partnership with PRISM, a faculty-led, student-run marketing agency at Virginia Tech managing 11 client accounts with 60+ team members. It's designed to be adaptable for any professional services organization.

For feature requests, bug reports, or questions about adapting MovaLab for your organization, please open an issue on GitHub or join our Discord community.

• 🌐 movalab.dev - Main website and documentation
• 🎮 demo.movalab.dev - Interactive demo (no signup required!)

• 📘 Contributing Guide - Complete setup walkthrough (START HERE!)
• 🎮 Demo Mode Guide - Running demos locally and in the cloud
• 🐳 Docker Setup - Local development with Docker
• 🚀 First Time Setup - Cloud deployment guide
• 🔄 Environment Switching - Local Docker ↔ Cloud Supabase

• 💻 Developer Guide - Comprehensive development documentation
• 📋 Feature List - Complete feature catalog
• 🗄️ Database Schema - Migration guide and database structure
• 🔒 Security Guide - Security architecture and best practices
• 📚 All Documentation - Full documentation index

• 💬 Discord Community - Chat with other users and maintainers
• 🐛 GitHub Issues - Report bugs or request features
• 📧 Email Support - For private inquiries

MovaLab is licensed under the Sustainable Use License.

You can:

• Use MovaLab for your agency's internal operations
• Self-host for your own business
• Modify the code for your internal use
• Offer consulting services helping others implement MovaLab

You cannot:

• Host MovaLab as a paid service for others
• Resell or white-label MovaLab
• Embed MovaLab in a commercial product

This is a "fair-code" license similar to n8n and other source-available projects. It protects against commercial exploitation while allowing agencies to use and benefit from the platform.

See LICENSE for complete terms.

Built for agencies who believe operational excellence — not just creative excellence — drives profitability.

MovaLab: Because your team deserves better than spreadsheet chaos and Slack pandemonium.