# Sales Dashboard
## Query Data
```sql sales_data
SELECT
date,
SUM(revenue) as total_revenue,
COUNT(*) as order_count
FROM orders
WHERE date >= DATE('now', '-30 days')
GROUP BY date
ORDER BY date DESC
```
## Revenue Trend
<LineChart data={sales_data} x="date" y="total_revenue" />
## Summary Metrics
Total Revenue: {sales_data.total_revenue.sum()}
Total Orders: {sales_data.order_count.sum()}Drag-and-drop interfaces create black boxes. Your reports live in silos, can't be version controlled, and are impossible to reproduce consistently.
No version control - changes are invisible
Black-box drag-and-drop interfaces
Hard to reproduce and test
Siloed workflows prevent collaboration
Expensive licensing costs
Everything in Git with full history
Code-first, transparent workflows
100% reproducible analytics
Collaborative like software engineering
Free and open source
Apply modern development practices to business intelligence. Version control, code reviews, testing, and CI/CD for your data products.
Every report, query, and dashboard lives in Git. Track changes, revert mistakes, and understand the complete history of your analytics.
Use pull requests and branches for BI workflows. Review changes before they go live, just like you do with code.
Automated testing and CI/CD for data products. Catch errors before they reach production dashboards.
Generate SQLPage dashboards, static sites, or embed analytics. Deploy to SQLite, PostgreSQL, or your own infrastructure.
Share and iterate like software engineers. Your entire team works on the same codebase with perfect synchronization.
Publication-quality visualizations that are responsive, interactive, and beautiful. No design skills required.
Five simple steps from code to production-ready dashboards
Query blocks execute inline and return structured data
Chart components automatically render your data
Version control all changes with standard Git workflows
Generate SQLPage dashboards or static sites
Code review and continuous improvement cycles
From executive dashboards to embedded analytics, Spry BI handles it all
Real-time KPI tracking with live data updates. Present metrics that matter to leadership.
Scheduled, reproducible reports that run automatically. Consistent insights every time.
Interactive analysis tools for data discovery. Filter, slice, and drill down into your data.
Customer-facing analytics embedded directly in your product. White-label ready.
Team dashboards and operational metrics. Keep everyone aligned with live data.
Audit-ready, version-controlled analytics. Prove reproducibility and track all changes.
See how Spry BI compares to legacy platforms
| Feature | Traditional BI | Spry BI |
|---|---|---|
| Version Control | ||
| Code Reviews | ||
| Reproducibility | ||
| Automated Testing | ||
| Cost | $$$ | Free/Open Source |
| Learning Curve | Steep | Markdown + SQL |
| Deployment | Complex | Simple |
Everything you need to build production-ready BI applications
Write queries in familiar SQL syntax. Support for SQLite, PostgreSQL, and DuckDB. Complex joins, window functions, and CTEs all work perfectly.
-- Reusable base query
WITH active_users AS (
SELECT user_id, last_seen
FROM users
WHERE last_seen > DATE('now', '-30 days')
)
SELECT
DATE(order_date) as date,
COUNT(*) as orders,
SUM(amount) as revenue
FROM orders
WHERE user_id IN (SELECT user_id FROM active_users)
GROUP BY DATE(order_date)## User Filters
<DateRange bind:startDate bind:endDate />
<Select bind:category options={categories} />
## Filtered Results
```sql filtered_data
SELECT * FROM sales
WHERE date BETWEEN {startDate} AND {endDate}
AND category = {category}
```User inputs and filters that update queries in real-time. Create interactive dashboards with dropdowns, date pickers, and text inputs.
Pre-built chart types for every visualization need. Line charts, bar charts, scatter plots, tables, and more. Responsive and accessible by default.
+ many more components
Treating BI as code unlocks the same benefits that transformed software development
Work together like engineering teams. Multiple people can work on the same dashboard simultaneously with proper merge conflict resolution.
Automated testing prevents errors from reaching production. Catch broken queries, data issues, and visualization bugs before users see them.
Faster iteration cycles mean more experiments and better insights. Live reload during development speeds up the feedback loop.
Every change is tracked in Git. Understand who changed what, when, and why. Perfect audit trail for compliance and debugging.
One codebase, infinite deployments. Use the same reports across dev, staging, and production. Deploy to multiple customers effortlessly.
Your data, your infrastructure, your control. No vendor lock-in. Export to any format, deploy anywhere, migrate anytime.
Install Spry and create your first BI report
Spry runs on the Deno runtime. Install it using:
curl -fsSL https://deno.land/install.sh | shCreate a new Spry project in the current directory using SQLite:
curl -fsSL https://sprymd.org/init.sh | sh -sThis sets up the default SQLite-based project structure.
Prepare the SQLPage auto-generated files:
./spry.ts spc --fs dev-src.auto --destroy-first --conf sqlpage/sqlpage.jsonRun Spry in development mode with auto-reload enabled:
./spry.ts spc --fs dev-src.auto --destroy-first --conf sqlpage/sqlpage.json --watchDeploy SQLPage components to the SQLite database:
./spry.ts task deployFinally, start SQLPage:
SQLPAGE_SITE_PREFIX="" sqlpage