File Display
Get Started
Get started with File Display in seconds. Sign up with your email, and you're automatically connected with your team. The platform uses your email domain to determine your company, so everyone at your organization sees the same data.
Sign Up with Email
Create an account using your work email. No credit card required.
Auto-Assigned to Company
Your email domain (e.g., @company.com) becomes your Client ID, linking you to your organization.
Collaborate with Team
Anyone else who signs up with the same email domain automatically joins your workspace.
Email Domain = Client ID
Your email domain automatically determines your organization. This means:
- john@acme.com and sarah@acme.com share the same workspace
- No manual invites needed—just sign up and collaborate
- Data isolation is automatic—you only see your company's data
Example
Role Assignment
The first person to sign up with a domain becomes the Founder with full access, including the ability to promote others to Admin and manage company settings.
Promoted by the Founder. Admins have full access except assigning the admin role, and can manage team members.
The default role for new signups. Editors can create reports, documents, and participate in chat. Founders/Admins can adjust roles.
Read-only access. Viewers can see all shared content but cannot create or edit reports, documents, or other resources.
How it works
File Display converts ad-hoc manual workflows into standardized, repeatable applications — replacing spreadsheet-driven processes with deterministic tooling and automated distribution.
01. Data Ingestion
Accepts Excel (.xlsx), CSV, or JSON files from any source — WMS exports, financial ledgers, delivery manifests, or other structured data formats.
02. Deterministic Processing
Custom business logic executes client-side in under 20ms. Validates data integrity, computes metrics, applies formatting rules, and flags anomalies — no AI inference, no network round-trip.
03. Output & Distribution
Produces a formatted Excel report, persists results to the database with full audit trail, and optionally triggers an AI-generated summary distributed to configured recipients via email.
Internal Tooling as a Service
Report creation tools are one implementation of the underlying architecture. File Display provides the shared infrastructure — auth, data persistence, shared docs, email delivery, real-time collaboration, and AI integration — so that new business logic can be plugged in rapidly without rebuilding common services.
System Architecture
File Display is built on a modern, high-performance stack designed for strict data isolation and real-time responsiveness.
Data Isolation & RLS
PostgreSQL Row Level Security ensures every query is filtered by company_id from the user's JWT.
Hybrid Execution Model
Business logic runs client-side for 0.02s speeds. Results selectively piped to server-side AI for summarization.
Modern Next.js Stack
Next.js 14+ with TypeScript. Supabase for Auth and Realtime subscriptions.
Immutable Audit Trails
Every processed file is serialized and stored, linked to the team Activity Log.
Download File Display Desktop App
Run File Display as a native desktop application on macOS or Windows. The app bundles the full Next.js server, all pages, and every API route into a single installer. On launch, it starts a local server and opens the app — same experience as the web version, running entirely on your machine. Auto-updates keep you on the latest version.
New
Deltamorph Desktop Download
Download the standalone Deltamorph AI code editor.
Zero Configuration
macOS users: Right-click the app and choose “Open” the first time to bypass Gatekeeper, since the app is not notarized with Apple.
API & Webhooks
Integrate File Display with your existing WMS, ERP, or other systems using our comprehensive REST API. With dozens of external endpoints across many resource groups, you can submit reports, manage webhooks, run anomaly detection, perform semantic search, control the AI agent, manage custom tools, schedule recurring reports, export data in bulk, and execute batch operations — all programmatically.
Getting Started
Go to the Developer page and create either a Standard API key or an AI Bundle key, depending on the endpoints you plan to call.
Set up webhook endpoints to receive notifications when reports complete.
Submit reports, retrieve data, and generate AI analyses programmatically.
Endpoint availability and request/response shapes are maintained in /api/v1/openapi.json. Use it as the source of truth for generated clients.
REST API
Submit reports programmatically from any system that can make HTTP requests.
- Submit CSV, XLSX, or JSON data
- Multi-file submissions for complex tools
- Automatic tool detection
- Idempotency key support
- Activity logging & audit trail
Webhooks
Receive real-time notifications when events occur in File Display.
- Report completed notifications
- AI analysis included in payloads
- HMAC-SHA256 signed payloads
- Automatic retry with backoff
- Delivery logs & monitoring
Authentication
All API requests require authentication using a Bearer token. Include your API key in the Authorization header.
Authorization: Bearer fd_live_xxxxxxxxxxxxxAPI Key Prefixes
fd_live_— Standard and AI Bundle keys- Key type is enforced server-side per endpoint.
Key Permissions
reports:read— Read reports, analytics, searchreports:write— Submit, export, manage tools/agentwebhooks:manage— Create & configure webhookskey_type=ai_bundle— Required for/api/v1/ai/chat- Use a Standard key for all other
/api/v1/*endpoints.
API Endpoints Reference
POSTWrite Operations
/api/v1/ai/chatDirect AI chat/completions endpoint for external integrations, backed by the Vercel AI Gateway.
ai_analysis feature + AI Bundle key type | Tier: Starter+/api/v1/reportsSubmit a report for processing. Supports single or multi-file submissions.
reports:write/api/v1/reports/analyzeGenerate AI analysis and optionally email it to recipients.
reports:write/api/v1/agentSend a message to the AI agent with tool-calling, memory, and context awareness.
reports:write/api/v1/anomalies/detectRun anomaly detection on submitted employee metrics. Returns detected anomalies with severity.
reports:write | Tier: Starter+/api/v1/searchSemantic search across historical reports and AI analyses using natural language.
reports:read | Tier: Pro+/api/v1/agent/streamStreaming AI agent endpoint (NDJSON). Real-time text chunks, tool calls, and memory updates.
Starter+/api/v1/agent/memoryAdd an entry to the AI agent's persistent memory.
reports:write | Tier: Starter+/api/v1/webhooksCreate a webhook endpoint programmatically. Returns the signing secret (shown once).
webhooks:manage | Tier: Starter+/api/v1/toolsCreate a custom tool with HTML/CSS/JS code. Auto-creates v1 version.
reports:write | Tier: Starter+/api/v1/tools/generateAI-generate tool code from a natural language prompt.
reports:write | Tier: Starter+/api/v1/filtersCreate or update an AI analysis filter for a specific tool.
reports:write | Tier: Starter+/api/v1/schedulesCreate a recurring report schedule using cron expressions or intervals.
reports:write | Tier: Pro+/api/v1/exportRequest a bulk data export (JSON or CSV). Small exports return synchronously; large exports run as background jobs.
reports:write | Tier: Starter+/api/v1/batchExecute multiple API operations in a single request. Operations run in parallel.
Pro+GETRead Operations
/api/v1/reports/:idGet the status and details of a submitted report.
reports:read/api/v1/reports/:id/downloadDownload the processed report file.
reports:read/api/v1/analyticsRetrieve historical analytics data for a tool.
/api/v1/activityGet team activity feed including API submissions.
/api/v1/filesList stored input and output files.
/api/v1/files/:idDownload a specific file by ID (binary or base64 format).
/api/v1/anomaliesList detected anomalies with optional aggregate stats.
Starter+/api/v1/search/historyRetrieve past semantic search queries and result counts.
Pro+/api/v1/agent/memoryList the AI agent's memory entries with category filters and search.
Starter+/api/v1/agent/settingsGet the AI agent configuration (data sources, roles, memory limits).
Starter+/api/v1/webhooksList webhook endpoints with stats (deliveries, success rate, failures).
webhooks:manage | Tier: Starter+/api/v1/webhooks/:idGet webhook details with delivery history and success rate metrics.
webhooks:manage | Tier: Starter+/api/v1/toolsList custom tools. Filter by visibility (private, shared, all).
Starter+/api/v1/tools/:id/versionsList all versions of a custom tool with code and default flag.
Starter+/api/v1/tools/:id/dataRead persistent data entries stored by a custom tool via ToolAPI.
Starter+/api/v1/filtersList active AI analysis filters by tool name.
Starter+/api/v1/filters/changelogView AI filter change history — who changed what, when, and the old vs new filter.
Starter+/api/v1/schedulesList recurring report schedules with run stats.
Pro+/api/v1/exportList previous data exports and their status.
Starter+/api/v1/export/:idCheck export status or download completed export result.
Starter+/api/v1/calendar/eventsList calendar events in a date range for your company.
Standard API key/api/v1/calendar/available-slotsReturn available time slots that do not overlap calendar events.
Standard API keyPUT / DELETEManagement Operations
/api/v1/webhooks/:idUpdate webhook configuration (URL, events, active status).
webhooks:manage/api/v1/tools/:idUpdate a custom tool. Auto-creates a new version if code changes.
reports:write/api/v1/agent/settingsUpdate agent configuration (data sources, memory retention, custom instructions).
reports:write/api/v1/schedules/:idUpdate a schedule (cron, active status, payload).
reports:write/api/v1/anomaliesAcknowledge or dismiss a detected anomaly.
reports:write/api/v1/webhooks/:idDelete a webhook endpoint.
webhooks:manage/api/v1/tools/:idDelete a custom tool and all its versions.
reports:write/api/v1/agent/memory?id=:idRemove a specific memory entry from the AI agent.
reports:write/api/v1/schedules/:idDelete a recurring report schedule.
reports:writeEndpoints by Group
| Group | Endpoints | What It Does |
|---|---|---|
| AI Chat | POST /api/v1/ai/chat | Direct chat/completions endpoint via AI Gateway (requires AI Bundle key) |
| Reports | GET POST GET/:id GET/:id/download POST/analyze | Submit files, track processing, download results, AI analysis with email |
| Analytics | GET | Historical report data by tool (up to 365 days) |
| Webhooks | GET POST GET/PUT/DELETE/:id POST/:id/test GET/:id/deliveries | Full lifecycle — HMAC-signed, auto-retry, delivery tracking |
| Anomalies | GET PATCH POST/detect | Statistical anomaly detection, severity classification, acknowledge/dismiss |
| Search | POST GET/history | Natural language semantic search via embeddings + pgvector |
| Agent | POST POST/stream GET/POST/DELETE/memory GET/PUT/settings | Streaming AI agent with 11 tools, persistent memory, configurable settings |
| Tools | GET POST GET/PUT/DELETE/:id versions data POST/generate | Custom HTML/JS tools with versioning, cloud data, AI code generation |
| Filters | GET POST DELETE GET/changelog | AI analysis context filters per tool with change history |
| Schedules | GET POST GET/PUT/DELETE/:id | Cron or interval-based recurring report schedules |
| Export | GET POST GET/:id | Bulk data export (JSON/CSV), sync or async job queue |
| Calendar | GET/events GET/available-slots | Calendar event retrieval and open-slot discovery within a date range |
| Batch | POST | Execute up to 500 API operations in one request (parallel) |
| Files | GET GET/:id | Browse and download stored input/output files |
| Activity | GET | Team activity feed with filtering by tool, action, user, date |
50+
Endpoints
16
Resource Groups
11
AI Agent Tools
4
API Tiers
Supported Tool IDs
Use these IDs for the tool parameter when submitting reports, querying analytics, or filtering data via the API.
forkliftForkliftpickerPickerreturnsReturnsshortsShortsskipsSkipstruck_errorsTruck ErrreplenReplenreconciliationDiffsloaderLoaderreturns_intelRetIntelCode Examples
Submit a Single-File Report
curl -X POST https://your-domain.com/api/v1/reports \
-H "Authorization: Bearer fd_live_xxxxx" \
-H "Content-Type: application/json" \
-d '{
"tool": "picker",
"file_name": "daily_report.xlsx",
"file_type": "xlsx",
"data": "<base64_encoded_file>",
"idempotency_key": "report-2024-01-15"
}'Submit a Multi-File Report
Tools like Forklift and Replen support multiple input files:
curl -X POST https://your-domain.com/api/v1/reports \
-H "Authorization: Bearer fd_live_xxxxx" \
-H "Content-Type: application/json" \
-d '{
"tool": "forklift",
"files": [
{
"file_name": "day_shift.xlsx",
"file_type": "xlsx",
"data": "<base64_encoded_file_1>"
},
{
"file_name": "night_shift.xlsx",
"file_type": "xlsx",
"data": "<base64_encoded_file_2>"
}
],
"idempotency_key": "forklift-2024-01-15"
}'Generate AI Analysis & Email
Send report data to generate an AI summary and email it to recipients:
curl -X POST https://your-domain.com/api/v1/reports/analyze \
-H "Authorization: Bearer fd_live_xxxxx" \
-H "Content-Type: application/json" \
-d '{
"tool": "forklift",
"data": "Employee,Moves,Hours\nJohn,150,8\nJane,200,8",
"report_date": "2024-01-15",
"send_email": true,
"email_recipients": ["manager@example.com", "team@example.com"]
}'Retrieve Analytics Data
curl -X GET "https://your-domain.com/api/v1/analytics?tool=forklift&days=30" \ -H "Authorization: Bearer fd_live_xxxxx"
Call the AI Bundle Chat Endpoint
Use an AI Bundle key from Developer Settings. Standard keys are rejected on this route.
curl -X POST https://your-domain.com/api/v1/ai/chat \
-H "Authorization: Bearer fd_live_xxxxx" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Summarize this shift report and highlight risks",
"model": "google/gemini-2.5-flash",
"temperature": 0.4,
"max_tokens": 1200
}'Get Calendar Availability Slots
Use a Standard key to fetch open slots from your company calendar.
curl -X GET "https://your-domain.com/api/v1/calendar/available-slots?from=2026-02-14T09:00:00Z&to=2026-02-14T18:00:00Z&slot_minutes=30&visibility=company" \ -H "Authorization: Bearer fd_live_xxxxx"
AI Report Analysis API
The /api/v1/reports/analyze endpoint generates AI-powered summaries and can automatically email them to your configured recipients (both internal team members and external addresses).
Request Fields
tool— Required tool IDdata— Report data (text or base64)is_base64— Set true if data is base64context_filter— Custom AI prompt (optional)report_date— Report date (YYYY-MM-DD)send_email— Email recipients (default: true)email_recipients— Override recipient listinclude_data_preview— Include data sample
Response Fields
analysis— AI-generated summary textanalysis_id— Saved analysis record IDcustom_filter_used— Filter that was appliedemail.sent— Number of emails sentemail.results— Per-recipient statusprocessing_time_ms— Processing duration
Webhook Events
Configure webhook endpoints to receive real-time notifications. All payloads are signed with HMAC-SHA256 for security verification. Webhook payloads include AI analysis when available.
report.createdAPI submissionsTriggered when a new report is submitted via the API.
report.completedIncludes AI analysisProcessing finished successfully. Includes summary stats, output file info, and AI analysis.
report.failedError detailsReport processing encountered an error. Includes error message and details.
Example Webhook Payload
{
"event": "report.completed",
"timestamp": "2024-01-15T10:30:00Z",
"data": {
"submission_id": "sub_abc123",
"tool": "forklift",
"status": "completed",
"input_filename": "daily_report.xlsx",
"output_filename": "forklift_report_2024-01-15.xlsx",
"records_processed": 150,
"processing_time_ms": 1250,
"ai_analysis": "Summary: Top performer John Smith with 200 moves...",
"date_range": "2024-01-15"
}
}Webhook Security
Verify webhook authenticity using the signature in the X-Webhook-Signature header.
// Node.js signature verification
const crypto = require('crypto');
function verifyWebhook(payload, signature, secret) {
const expected = crypto
.createHmac('sha256', secret)
.update(payload)
.digest('hex');
return crypto.timingSafeEqual(
Buffer.from(signature),
Buffer.from(expected)
);
}Request Headers
X-Webhook-Signature— HMAC-SHA256 signatureX-Webhook-Timestamp— Unix timestampX-Webhook-Event— Event type
Retry Behavior
- 5 retry attempts with exponential backoff
- Auto-disabled after consecutive failures
- Full delivery logs in Developer dashboard
Rate Limits
- 100 requests per minute per API key
- 10 MB max file size per request
- Rate limit headers in response
Headers: X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset
Error Codes
- 400Bad Request / Validation Error
- 401Unauthorized / Invalid API Key
- 403Forbidden / Insufficient Permissions
- 404Resource Not Found
- 429Rate Limit Exceeded
- 500Internal Server Error
Ready to integrate?
Create your API keys and configure webhooks in the Developer dashboard.
Dashboard
The dashboard serves as the central hub for all platform activity. It provides immediate visibility into reports, projects, team members, communications, and historical activity. Every metric updates in real-time, and users can customize which modules appear based on their workflow preferences.
Overview Cards
- Projects with status indicators
- Quick access to all tools (built-in + custom)
- Report counts with date filtering
- Shared documents overview
- Team members with role badges
- Chat with unread indicators
Customization
- Customizable dashboard title
- Background color themes
- Hide/show individual cards
- Tab visibility preferences
- Company-wide settings (admins)
- Restore hidden tabs in settings
Activity History
The history tab provides a complete audit trail of all platform activity. Each entry includes the action type, user, timestamp, and where applicable, direct links to the relevant content (documents, chat sessions, reports).
Processing Tools
File Display includes specialized tools built for your specific workflows. Each tool accepts Excel or CSV files, processes them entirely client-side using deterministic algorithms, and generates formatted reports. Processing typically completes in under 20 milliseconds, regardless of file size.
Custom Tools Built For You
Each tool is engineered specifically for your business processes. We analyze your existing workflows, understand your data formats, and build deterministic processing logic that transforms your raw input files into actionable reports.
Your Data Format
Works with your existing files
Your Logic
Custom calculations built in
Your Output
Reports formatted your way
Common Features Across All Tools
Build Your Own Tools
Any team member can create custom tools using the Build editor on the AI page. Describe what you want in plain English and let AI generate the code, or write HTML/CSS/JS directly in a browser-based editor with live preview. Toggle Data Persistence to give your tool a cloud backend. Choose to keep tools private or share them with your whole team. Every save creates a new version you can switch between. Model selectors on Build and Chat auto-load from the AI Gateway model catalog, filtered by a platform allowlist for reliability.
AI Code Generator
Describe your tool in natural language. Toggle Data Persistence on/off to tell AI whether to wire up cloud storage.
Code Editor + Live Preview
Dark-themed editor with tab support and a real-time sandboxed iframe preview
Sandboxed Execution
Tools run in a sandboxed iframe — no access to app data, auth tokens, or external APIs
Data Persistence Toggle
One-click toggle tells AI to wire up ToolAPI for cloud storage — saves/loads data via postMessage bridge to JSONB
Version History
Every save creates a new version. Switch between versions, set any as default, load old versions into the editor.
Private or Shared
Keep tools private for your own use, or share with your whole team so they appear on everyone's Tools page.
Data Viewer
Tool creators can inspect all stored database entries for each tool directly from the tool card — no SQL needed.
ToolAPI — Cloud Data Persistence
Custom tools that need to remember data across sessions (trackers, todo lists, inventories) use ToolAPI — a bridge that safely proxies data between the sandboxed iframe and a company-scoped Supabase table via postMessage.
Save Data
await ToolAPI.save({ items: [...] });
await ToolAPI.save(data, 'settings');Load Data
const data = await ToolAPI.load();
const all = await ToolAPI.loadAll();Version History
Every save automatically creates a new version. Each tool card shows a version dropdown where you can browse all versions, load any version into the editor, set any version as the default (live) version, or delete old versions. The tool runner page also has a version switcher to preview any version.
Private or Shared
Tools default to private — only visible to the creator. Toggle "Shared with team" to make a tool visible to everyone in your company. Shared tools appear on all team members' Tools pages alongside built-in tools. Only the creator can edit shared tools.
Data Viewer for Tool Creators
Tool creators can inspect all backend data entries stored by their tools without leaving the Build page. Click the database icon on any tool card to expand an inline panel showing every key, its JSON value, and the last-updated timestamp.
{ "items": ["Widget A", "Widget B"], "count": 2 }{ "theme": "dark", "sortBy": "date" }2 keys stored via ToolAPI
Great for building:
AI Tool Builder — Generate from Spreadsheet
Upload any .xlsx or .csv file and AI will analyze its structure — column types, statistics, sample data — then automatically generate a complete file-processing tool with custom business logic tailored to your data. The generated tool matches the dark terminal UI used by the built-in warehouse tools (Picker, Forklift, etc.).
Upload & Analyze
Drag-and-drop a spreadsheet. The profiler extracts headers, column types, numeric stats, and sample rows — all client-side.
Optional Instructions
Describe what the tool should do, or leave blank and AI decides the best processing logic based on your data.
3-Phase AI Pipeline
Analyze → Generate → Review. AI plans the tool, writes full HTML/CSS/JS with ExcelJS integration, then self-reviews for bugs.
Live Preview & Save
Preview the generated tool in a live iframe, edit the code if needed, then save as private or shared with your team.
How It Works
From Self-Service to Full-Build
Build is designed as a first step — it lets your team solve their own problems immediately by building lightweight front-end and backend tools without waiting on developers. Many day-to-day needs (calculators, trackers, checklists, data entry forms) can be solved entirely this way, with AI generating the code and ToolAPI handling data persistence.
Build
Create your own tools with AI + code editor. Sandboxed HTML/CSS/JS with cloud data persistence. Instant, no developers needed.
Developer Tab
For complex solutions — integrations, multi-page apps, advanced logic — request a project and File Display's team builds it for you.
When to use each: If you can describe your tool in a sentence or two and it works as a standalone page (calculator, tracker, form), Build handles it. If your solution needs server-side logic, third-party API integrations, multi-page workflows, complex data pipelines, or tight integration with existing platform features — submit a project request in the Developer tab and we'll build it as a fully integrated feature on the platform.
Logic Fingerprinting
Every tool's processing logic is deterministic and version-controlled. This means the exact same input will always produce the exact same output—creating a "fingerprint" that guarantees transparency and enables precise comparisons between versions.
Why It Matters
- Auditability: Every calculation can be traced and verified
- Reproducibility: Re-run any historical report with identical results
- Version Control: Compare outputs before and after logic updates
- Trust: No black-box AI randomness in core calculations
How It Works
- All processing logic lives in versioned source code
- Transformations are explicit functions, not learned models
- Every change is tracked with full commit history
- Test mode enables safe validation of logic changes
// Same input → Same output, every time
Input: forklift_data_2026.xlsx
Logic: v2.4.1 (git: a3ec539)
Output: LOPSPRO_Report_Jan27.xlsx
Fingerprint: sha256:8f2a9c...
Test Mode
Every tool includes a Test Mode toggle that lets you experiment safely. Reports generated in test mode are flagged and automatically excluded from analytics, leaderboards, and business metrics — so you can validate changes without polluting real data.
Safe Experimentation
Test new logic or unfamiliar data without consequences
Clean Analytics
Test data never appears in dashboards or reports
Version Comparison
Compare outputs between logic versions safely
When to Use Test Mode
File Display AI
File Display AI provides conversational assistance and automated report analysis. The AI layer complements rather than replaces deterministic processing—data transformation remains algorithmic and verifiable, while AI provides interpretation and insights that can be automatically distributed to your team.
AI Chat Assistant
- Conversational interface for questions about operations
- Knowledge of the complete File Display system
- Session history with team sharing (optional)
- Private mode for sensitive queries
- Collaborative sessions with join capability
AI-Enhanced Reporting
Transform raw reports into actionable insights with integrated AI summaries. Configure exactly how summaries are generated and who receives them—all from the Email Settings panel on each tool.
Configurable Email List
Set up recipient lists per tool. When a report is processed, AI summaries can be automatically emailed to managers, supervisors, or anyone who needs to stay informed—without them needing to log in.
Custom AI Filters
Define exactly what the AI focuses on for each tool. Want summaries that prioritize errors? Focus on top performers? Highlight trends? Configure the AI filter to match your operational priorities.
AI Summary Features
Generate intelligent analysis of any processed report. The AI extracts key findings, identifies patterns, and ranks insights by importance.
- Critical issues highlighted first
- Top/bottom performers with exact numbers
- Pattern and trend identification
- One-click email with summary attached
Email Settings Panel
Access the Email Settings from any tool's reports tab to configure both recipient lists and AI behavior.
- Add/remove email recipients per tool
- Custom AI filter prompts per tool
- Filter change history tracking
- Editor+ permission required to modify
RAG Semantic Search
Ask questions about your historical reports using natural language. Powered by vector embeddings (pgvector), File Display understands the meaning of your queries — not just keywords.
Natural Language Queries
Ask questions like "Show me our best forklift performance days" or "When did we have the highest picker efficiency?"
- Searches across all historical reports
- Ranks results by relevance
- Returns context and summaries
Historical Context in AI
AI analysis now automatically includes relevant historical data for comparison, enabling insights like "productivity is 15% above last month's average."
- Auto-fetches similar past reports
- Compares current vs historical metrics
- Identifies trends over time
AI-Powered Anomaly Detection
Automatically detect unusual employee performance by comparing against rolling historical baselines. Get alerted when metrics deviate significantly from expected ranges.
Rolling Baselines
Maintains 30-day rolling averages per employee/metric with standard deviation tracking.
Smart Alerts
Email notifications for medium, high, and critical severity anomalies with severity badges.
Severity Levels
Critical (>50%/3σ), High (>35%/2.5σ), Medium (>20%/2σ), Low thresholds.
How it works: When a report is processed, File Display compares each employee's metrics (moves/hour, scan %, etc.) against their personal baseline. Significant deviations are flagged, stored for review, and optionally trigger email alerts. Acknowledge or dismiss anomalies directly from the dashboard widget.
Distributed Caching (Redis)
Enterprise-grade caching layer using Upstash Redis for lightning-fast data access and reduced database load.
What's Cached
- User profiles & company settings
- API key validation (10x faster)
- Rate limiting counters
- Permission lookups
Benefits
- Automatic cache invalidation on updates
- Graceful degradation if Redis unavailable
- Pattern-based cache clearing
- Admin monitoring endpoint
Background Job Queue (QStash)
Serverless job queue system using Upstash QStash for reliable background processing with automatic retries.
Job Types
- Email delivery with retries
- Webhook delivery + backoff
- AI analysis generation
- Anomaly detection
Reliability Features
- Exponential backoff retries
- Dead letter queue
- Job status tracking
- Deduplication support
Monitoring
- Job logs per execution
- Stats by job type
- Progress tracking
- Cancel/retry from API
How it works: Long-running operations are queued instead of blocking API requests. Workers process jobs in the background with automatic retries on failure. Jobs are tracked in the database with full logging, allowing you to monitor progress and diagnose issues. If QStash is unavailable, the system gracefully falls back to synchronous processing.
API Tiers & Usage Control
Tiered API access with feature gating, rate limiting, and usage quotas. Manage per-company access levels from GodView.
Feature Gating
- Webhooks (Starter+)
- AI Analysis (Starter+)
- Batch Uploads (Pro+)
- Semantic Search (Pro+)
Rate Limiting
- Per-minute limits
- Per-day limits
- Monthly quotas
- Custom overrides
Admin Controls
- GodView tier panel
- Per-company settings
- Usage monitoring
- Quota progress bars
How it works: Each company is assigned a tier that determines their API access. Features are automatically gated based on tier - requests to disabled features return clear upgrade prompts. Usage is tracked monthly with quota enforcement. Admins can override limits per-company from GodView.
Error Tracking & Monitoring (Sentry)
Centralized error tracking with Sentry integration, structured logging with correlation IDs, and comprehensive health checks.
- Sentry integration
- Stack trace capture
- Session replay
- Error grouping
- JSON log format
- Correlation IDs
- Log levels
- Request tracing
- /api/health endpoint
- Component status
- Liveness/readiness
- Alert aggregation
How it works: Errors are automatically captured and sent to Sentry with full context including user info, correlation IDs, and stack traces. The structured logging service outputs JSON in production for easy aggregation by log management tools. Health check endpoints provide status for load balancers, while the monitoring API aggregates alerts from multiple sources including failed jobs, anomalies, and API errors.
AI Agent System
A full agentic AI system that serves as your company's intelligent data hub. The agent can query your entire database (reports, designs, documents), synthesize cross-report analyses, send email notifications, and maintain a persistent company knowledge base ("snowball" memory). All access is governed by role-based permissions configured per company.
Agent Chat Interface
The /chat page is a full agentic hub with streaming NDJSON responses, inline tool call visualization, and generative UI components (tables, charts, summaries).
- Multi-tab interface: Chat, Build, Log, Memory, Settings
- Streaming responses with tool call display
- Generative UI: dynamic tables, charts, summaries
- Chat history persistence via Supabase
Agent Tools
The agent uses Gemini function calling to invoke a suite of specialized tools. It can chain multiple tools for complex multi-step analyses.
- queryReports — query any report type by date/filters
- synthesizeReports — cross-report analysis
- sendEmail — send notifications via Resend
- searchKnowledge, addToMemory, getMemoryContext
- queryDocuments, getCompanyStats
Company Knowledge Base ("Snowball")
The agent maintains a persistent, growing knowledge base per company. Insights, summaries, facts, decisions, and preferences are stored with importance ratings and auto-expire after configurable periods. This "snowball" gives the AI cumulative context about your operations over time.
Memory Categories
Insight, Summary, Fact, Decision, Preference — each with 1-5 importance rating and optional expiry.
Full-Text Search
Search the knowledge base using natural language. The agent automatically includes relevant memory in its system prompt.
Auto-Pruning
Expired entries are automatically cleaned. Founders can prune manually or configure retention policies.
Role-Based Agent Access
The founder configures which roles can access the agent and which data sources are available. Permissions are enforced server-side via RLS and the agent_settings table.
Founder Settings Panel
Company founders have a dedicated settings tab in the agent interface to configure every aspect of the AI's behavior.
- Toggle data sources (reports, designs, docs)
- Configure per-role permissions
- Set memory retention period
- Custom AI instructions
- Enable/disable auto-synthesize and digest emails
Agent Architecture
Database Tables
3
agent_memory, agent_settings, agent_tasks
Core Modules
5
permissions, memory, tools, orchestrator, renderer
API Routes
7
chat, settings, memory, stream, v1 endpoints
Agent Tools
12
Gemini function calling via structured schemas
Team Collaboration
Real-time collaboration is built into every aspect of the platform. Team members can communicate through chat, see who's online across every page, and work together on documents simultaneously — all powered by Supabase Realtime. Everything is company-scoped with full data isolation between organizations.
Team Chat
Full groupchat auto-created per company. Create direct messages or custom groups. Real-time delivery with per-room notifications.
Calendar
Full scheduling system with personal & company calendars. Grid and list views.
@Mentions
Tag team members in any chat. Mentions appear in dedicated inbox with unread counts. Mark as read individually.
Member Profiles
Click any team member to view their profile with quick actions: start a DM, begin AI chat, create shared doc, or view activity.
Support
Built-in support channel for admin communication. Threaded conversations with read receipts.
Member Quick Actions
From any team member's profile modal, instantly launch collaboration workflows:
Opens private DM instantly
Ask AI about member activity
Private doc just for you two
Filter history by member
Notification System
Granular control over notifications with 10 configurable categories. Each user can customize their preferences, and security alerts remain always-on for account protection.
Calendar — Scheduling System
Personal & company calendars for team scheduling
A full-featured calendar and scheduling system at /calendar. Every user has a personal calendar and a shared company calendar. Events can be published to one or both and appear on the calendars of all invited participants.
Grid & List Views
Switch between a month grid view with color-coded event chips and a chronological list view with expandable event details. Both views update in real-time via Supabase Realtime.
Personal & Company Calendars
Toggle between “My Calendar” (events you created or are invited to) and “Company” (shared events visible to the whole team). Events can target personal, company, or both calendars.
Event Types
General, Meeting, Deadline, Reminder, Task
Activity Logging
All events logged to history in real time
Event Details
Each event includes: title, description, event type with color coding, date/time range (or all-day), location, external links, participant selection from the team roster, and visibility controls (personal / company / both).
Multiplayer — Real-Time Presence
See who's online, where they are, and what they're doing
Every page in the platform is multiplayer-aware. Supabase Realtime powers live presence tracking, typing indicators, and collaborative editing across the entire app. Users see real-time avatar stacks showing who else is on the same page, and typing indicators appear in chat and document editors as colleagues type.
Company-Wide Presence
A global presence channel tracks every online user across the platform. The dashboard shows who's online right now, which page they're on, and what resource they're viewing. Presence heartbeats auto-expire stale sessions.
Collaborator Avatars
Every page that supports collaboration shows a live avatar stack of current viewers. Avatars appear in documents, design studio, chat rooms, reports, and tool pages with colored rings and tooltips.
Typing Indicators
Broadcast-powered typing indicators show who is currently composing a message or editing a document. Debounced to avoid flickering, with automatic timeout if the user stops typing.
Real-Time Sync
Postgres Changes subscriptions push database updates to all connected clients instantly. New chat messages, document edits, tool creations, and call events appear live without polling or page refresh.
Multiplayer-Enabled Pages
Shared Documents
The documents module provides a collaborative workspace for team documentation. Documents update in real-time across all connected users, with automatic saving and version tracking. Sharing controls allow documents to be private, company-wide, or shared with specific team members.
Document Features
- Real-time collaborative editing
- Auto-save with timestamp display
- Mobile-optimized editor
- Deep linking from activity log
Sharing Modes
- Private: Only you can access
- DM Style: Shared with just one other person
- Company: All team members can view/edit
- View Only: Company can view but not edit
DM-Style Documents
Create private documents shared exclusively between you and one other team member. Perfect for 1:1 notes, feedback, or private collaboration. When you click "Start Doc" from a member's profile, a DM document is automatically created with RLS-enforced privacy—only you two can see it.
Database-Level Privacy
RLS policies enforce access for exactly two users
No Team Activity Log
DM docs don't appear in company-wide activity
Real-Time Sync
Both users see edits instantly like any doc
Account & Settings
Personalize your experience with comprehensive account settings. Manage your profile, customize which dashboard tabs are visible, configure notification preferences, and access your activity history including mentions and support conversations.
Profile Settings
- Display name customization
- Password management
- Tab visibility controls (show/hide)
- Email notification preferences
Activity & Mentions
- View mentions from team members
- Support conversation history
- Direct message support team
- Unread notification badges
Granular Member Permissions
Founder-Only Feature
Client ID founders have complete control over every permission for every member in their organization. Configure exactly what each team member can access, see, and modify with unprecedented granularity.
Tool Access Control
- Show/hide any of the 11 tools per user
- Control Analytics tab visibility per tool
- Control AI tab visibility per tool
- Independent settings per team member
Settings Access Control
- Email settings edit permissions
- AI filter configuration access
- Report settings management
- Dashboard tab visibility overrides
Permission Presets
Create and save reusable permission templates that can be quickly applied to multiple team members. Perfect for onboarding new users or standardizing access levels across departments.
Analytics & Tracking
Every action in File Display is logged and trackable. The activity log provides a complete audit trail, while the leaderboard gamifies team engagement with weighted activity scoring. Admins have access to platform-wide analytics for comprehensive oversight.
Activity Tracking
- Filter by user, date range, action type
- Direct links to related content
- Detailed action metadata
- Export capabilities
Team Leaderboard
Activity scoring with weighted points:
Security & Permissions
Security is foundational to File Display. Every database table enforces Row Level Security policies that automatically filter data by company. Users never see data from other organizations, and this isolation is enforced at the database level, not the application level.
Authentication
JWT-based secure login
Row Level Security
Database-enforced isolation
Company Boundaries
Automatic data partitioning
Role Permissions
Granular access control
Role Permissions
Multi-Tenancy Architecture
File Display uses a shared-database, company-isolated architecture. Every table includes a company_id foreign key, and Row Level Security policies ensure users can only access rows belonging to their company. This provides the isolation benefits of separate databases with the operational simplicity of a single schema.
Company assignment
By email domain
Data filtering
Database-enforced
Zero trust
RLS on every query
Technical Architecture
File Display is a full-stack multi-tenant platform built on Next.js 16 with React 19, backed by Supabase (PostgreSQL + pgvector + RLS), dual AI providers, distributed caching, background job queues, and a Deltamorph desktop AI code editor. All file processing is client-side for maximum speed; the server handles auth, AI orchestration, email, and data persistence.
Frontend
- Next.js 16: App Router + Turbopack
- React 19: Server components, hooks, Suspense
- TypeScript: Strict type-safe codebase
- Tailwind CSS 4: Utility-first styling
- ExcelJS: Client-side spreadsheet processing
- Recharts: Data visualization & charts
Backend & Data
- Supabase: Auth, DB, realtime, storage
- PostgreSQL + pgvector: RLS multi-tenancy & vector search
- Upstash Redis: Distributed caching & rate limiting
- Upstash QStash: Background job queues & cron
- Resend: Transactional & notification email
- Sentry: Error tracking & performance monitoring
AI & Infrastructure
- Vercel AI Gateway: Unified multi-provider inference layer for chat, build, and API endpoints
- Google/OpenAI/Anthropic models: Selected via Gateway allowlist and dynamic model discovery
- Vercel: Hosting, serverless, edge CDN
- Deltamorph Desktop: AI code editor for macOS & Windows (VS Code fork)
- GitHub Actions: CI/CD for web & desktop builds
- MCP Server: AI agent integration protocol
Multi-Tenancy Model
Every table includes a company_id column with Row Level Security (RLS) policies that automatically scope all queries to the authenticated user's company. Users are assigned to companies by email domain. Application code never manually filters by company — RLS handles it at the database layer.
Model Context Protocol (MCP)
File Display integrates with the Supabase MCP server, connecting AI-powered development tools directly to the platform's database and services. MCP (Model Context Protocol) is an open standard that lets AI assistants interact with live data sources securely.
What MCP Enables
- Live Database Queries: AI assistants can query tables, inspect schemas, and run SQL directly against the project database
- Migration Management: Apply and list database migrations without leaving the editor
- Edge Function Deployment: List, inspect, and deploy Supabase Edge Functions
- Type Generation: Auto-generate TypeScript types from the live database schema
- Logs & Debugging: Retrieve service logs for API, Postgres, Auth, Storage, and Realtime
How It Works
.cursor/mcp.json config file connects the IDE to the Supabase hosted MCP serverAvailable MCP Tools
list_tables
List database tables
execute_sql
Run SQL queries
apply_migration
Apply migrations
list_migrations
View migrations
get_logs
Retrieve service logs
get_advisors
Security & perf tips
generate_types
TypeScript types
deploy_function
Deploy edge functions
list_extensions
Postgres extensions
get_project_url
Project API URL
get_anon_key
Publishable keys
search_docs
Search Supabase docs
Platform Statistics
Current repo snapshot with refreshed codebase metrics after recent module cleanup. Core app logic remains TypeScript-first with Supabase migrations tracked in-repo.
0
Lines of Code
0
Source Files
0+
API v1 Routes
0
Migrations
0
Git Commits
30
Pages
16
Components
25
Dependencies
Codebase Breakdown
Frontend Pages
30
React pages with routing
API Routes
101
Server-side endpoints (35 external v1)
Library Modules
70
Shared utilities & hooks
TypeScript / TSX
79.1k
Lines across 230 files