<div>

  <h2>Installation and Deployment Guide</h2>

  <p>This guide covers setting up TableOS on a local development machine and deploying it to a production VPS. The system has three components: a Django backend, a Next.js frontend, and a Flutter mobile app. Set up the backend first — the frontend and mobile app both depend on it.</p>

  <h3>Prerequisites</h3>
  <ul>
    <li>Python 3.10 or higher</li>
    <li>Node.js 18 or higher and npm</li>
    <li>Flutter 3.41 and Dart 3.11</li>
    <li>Android Studio (for Android emulator) or Xcode (for iOS simulator)</li>
    <li>Git</li>
    <li>A Razorpay account with a key ID and secret (for payment features)</li>
  </ul>

  <h3>1. Clone the Repository</h3>
  <pre><code>git clone https://github.com/your-org/tableos.git
cd tableos</code></pre>

  <h3>2. Backend Setup (Django 5)</h3>

  <h4>Create and activate virtual environment</h4>
  <pre><code>cd Backend
python -m venv venv
source venv/bin/activate        # Linux / macOS
venv\Scripts\activate           # Windows</code></pre>

  <h4>Install dependencies</h4>
  <pre><code>pip install -r requirements.txt</code></pre>

  <h4>Configure environment variables</h4>
  <pre><code>cp .env.example .env</code></pre>

  <p>Open <code>.env</code> and set the following:</p>
  <pre><code>SECRET_KEY=your-django-secret-key-here
DEBUG=True
ALLOWED_HOSTS=localhost,127.0.0.1
DB_PATH=db.sqlite3
JWT_ACCESS_TOKEN_LIFETIME_MINUTES=60
JWT_REFRESH_TOKEN_LIFETIME_DAYS=7
RAZORPAY_KEY_ID=rzp_test_xxxxxxxxxxxxxxxx
RAZORPAY_KEY_SECRET=your_razorpay_secret
ZOMATO_WEBHOOK_SECRET=your_zomato_secret
SWIGGY_WEBHOOK_SECRET=your_swiggy_secret
CHANNEL_LAYER=memory
CORS_ALLOWED_ORIGINS=http://localhost:3000</code></pre>

  <p>For production, set <code>CHANNEL_LAYER=redis</code> and add <code>REDIS_URL=redis://localhost:6379/0</code>.</p>

  <h4>Run migrations and seed demo data</h4>
  <pre><code>python manage.py migrate
python manage.py seed</code></pre>

  <p>The seed command creates a demo restaurant (ID: 1), a full menu, table zones, and five staff accounts:</p>
  <pre><code>owner@spicegarden.com     / password123 / PIN 1234
manager@spicegarden.com   / password123 / PIN 2345
cashier@spicegarden.com   / password123 / PIN 3456
waiter@spicegarden.com    / password123 / PIN 4567
chef@spicegarden.com      / password123 / PIN 5678</code></pre>

  <h4>Start the backend server</h4>
  <pre><code>daphne restaurant_pos.asgi:application</code></pre>

  <p>The backend is now running at <code>http://localhost:8000</code>. Swagger UI is available at <code>http://localhost:8000/api/docs/</code>.</p>

  <h4>Run tests</h4>
  <pre><code>python manage.py test tests --verbosity=2</code></pre>

  <h3>3. Frontend Setup (Next.js 16)</h3>

  <pre><code>cd ../Frontend
npm install
cp .env.example .env.local</code></pre>

  <p>Set the following in <code>.env.local</code>:</p>
  <pre><code>NEXT_PUBLIC_API_URL=http://localhost:8000
NEXT_PUBLIC_WS_URL=ws://localhost:8000</code></pre>

  <pre><code>npm run dev</code></pre>

  <p>The admin dashboard is now running at <code>http://localhost:3000</code>. Log in with the owner credentials from the seed data above.</p>

  <h3>4. Mobile App Setup (Flutter)</h3>

  <pre><code>cd ../Mobile/restaurant_pos_mobile
flutter pub get</code></pre>

  <p>Create a <code>.env</code> file in the mobile project root:</p>
  <pre><code>API_URL=http://10.0.2.2:8000
WS_URL=ws://10.0.2.2:8000
RAZORPAY_KEY_ID=rzp_test_xxxxxxxxxxxxxxxx</code></pre>

  <p>Use <code>10.0.2.2</code> for the Android emulator. For iOS simulator, use <code>localhost</code>. For a physical device on the same network, use the backend machine's LAN IP (e.g. <code>192.168.1.x</code>).</p>

  <pre><code>flutter run</code></pre>

  <p>Log in with PIN <code>4567</code> (waiter) or <code>5678</code> (chef/KDS) using restaurant ID <code>1</code>.</p>

  <h3>5. Production Deployment (VPS with Nginx)</h3>

  <h4>Server requirements</h4>
  <ul>
    <li>Ubuntu 22.04 LTS</li>
    <li>Python 3.10+, Node.js 18+, Redis</li>
    <li>Nginx</li>
    <li>A domain name with DNS pointing to the server</li>
    <li>SSL certificate via Certbot (Let's Encrypt)</li>
  </ul>

  <h4>Install system dependencies</h4>
  <pre><code>sudo apt update
sudo apt install python3-pip python3-venv nodejs npm redis-server nginx certbot python3-certbot-nginx -y</code></pre>

  <h4>Backend production setup</h4>
  <pre><code>cd /var/www/tableos/Backend
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
pip install gunicorn</code></pre>

  <p>Update <code>.env</code> for production:</p>
  <pre><code>SECRET_KEY=your-production-secret-key
DEBUG=False
ALLOWED_HOSTS=api.yourdomain.com
DB_PATH=/var/www/tableos/data/db.sqlite3
CHANNEL_LAYER=redis
REDIS_URL=redis://127.0.0.1:6379/0
CORS_ALLOWED_ORIGINS=https://app.yourdomain.com</code></pre>

  <pre><code>python manage.py migrate
python manage.py collectstatic --noinput</code></pre>

  <h4>Systemd service for Daphne (ASGI)</h4>
  <pre><code># /etc/systemd/system/tableos-backend.service
[Unit]
Description=TableOS Django ASGI
After=network.target

[Service]
User=www-data
WorkingDirectory=/var/www/tableos/Backend
EnvironmentFile=/var/www/tableos/Backend/.env
ExecStart=/var/www/tableos/Backend/venv/bin/daphne \
    -u /run/tableos/daphne.sock \
    restaurant_pos.asgi:application
Restart=always

[Install]
WantedBy=multi-user.target</code></pre>

  <pre><code>sudo mkdir -p /run/tableos
sudo chown www-data:www-data /run/tableos
sudo systemctl daemon-reload
sudo systemctl enable tableos-backend
sudo systemctl start tableos-backend</code></pre>

  <h4>Nginx configuration</h4>
  <pre><code>server {
    server_name api.yourdomain.com;

    location / {
        proxy_pass http://unix:/run/tableos/daphne.sock;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /static/ {
        alias /var/www/tableos/Backend/staticfiles/;
    }
}</code></pre>

  <pre><code>sudo certbot --nginx -d api.yourdomain.com
sudo nginx -t && sudo systemctl reload nginx</code></pre>

  <h4>Frontend production build and deployment</h4>
  <pre><code>cd /var/www/tableos/Frontend
npm install
NEXT_PUBLIC_API_URL=https://api.yourdomain.com \
NEXT_PUBLIC_WS_URL=wss://api.yourdomain.com \
npm run build
npm run start -- -p 3000</code></pre>

  <p>Use PM2 or a systemd service to keep the Next.js process running in production.</p>

  <h4>Mobile app production build</h4>
  <p>Update the <code>.env</code> file in the mobile project with the production API URL, then build the release APK:</p>
  <pre><code>flutter build apk --release
# or for iOS
flutter build ipa --release</code></pre>

  <p>Distribute the APK directly to devices or publish via the Play Store. For enterprise internal distribution, the APK can be hosted on any file server and sideloaded.</p>

  <h3>6. Simulating Aggregator Orders (Development)</h3>
  <pre><code>python manage.py simulate_aggregator --source zomato --restaurant-id 1
python manage.py simulate_aggregator --source swiggy --restaurant-id 1</code></pre>

  <h3>7. Testing WebSocket Connections</h3>
  <pre><code># Install wscat globally
npm install -g wscat

# Get a JWT token first
curl -s -X POST http://localhost:8000/api/auth/login/ \
  -H "Content-Type: application/json" \
  -d '{"email":"owner@spicegarden.com","password":"password123"}' \
  | python -m json.tool

# Connect to WebSocket channels
wscat -c "ws://localhost:8000/ws/owner/1/?token=ACCESS_TOKEN"
wscat -c "ws://localhost:8000/ws/floor/1/?token=ACCESS_TOKEN"
wscat -c "ws://localhost:8000/ws/kds/1/1/?token=ACCESS_TOKEN"</code></pre>

</div>

<div>

  <p>Most restaurant software is either too expensive to license long-term, or so generic that it needs months of configuration before it fits your operation. TableOS is different. It is a complete, production-grade restaurant operating system that you buy once, own outright, and deploy on your own infrastructure. Whether you are building a SaaS product for restaurants, setting up software for a single outlet, or white-labeling a POS for your agency clients, this codebase gives you a real head start — not a prototype.</p>

  <h2>What This Product Does</h2>

  <p>TableOS is a four-component system: a Django 5 backend with REST APIs and WebSocket channels, a Next.js 16 admin dashboard for owners and managers, and a Flutter 3 mobile app that runs in two modes — a waiter app for floor staff and a kitchen display system for chefs. All four components are included in a single purchase.</p>

  <p>The backend is built with Django REST Framework and Django Channels running on Daphne, which means every status update — table status, order fires, KOT completion, payment settlement — broadcasts in real time to all connected clients without polling. The system uses SQLite with WAL mode out of the box, which is fine for most single-outlet deployments, and can be switched to PostgreSQL for multi-tenant or cloud deployments.</p>

  <p>The admin dashboard covers the full lifecycle of a restaurant shift: live floor plan with table status colors, order creation and editing, firing items to kitchen, GST-formatted invoice generation, Razorpay settlement, loyalty points, aggregator order feeds from Zomato and Swiggy, analytics with heatmaps and CSV exports, and staff management with role-based access control. The mobile app handles the same workflows on the floor — waiters can browse the menu, build orders with variants and modifiers, fire to kitchen, and close bills from their phone or tablet.</p>

  <h2>Key Features</h2>

  <ul>
    <li>Multi-role authentication with both email/password and a 4-digit PIN for shared kitchen tablets, with five distinct RBAC roles: owner, manager, cashier, waiter, chef</li>
    <li>Live floor plan with real-time table status updates via WebSocket — no refresh required</li>
    <li>Full order management supporting menu variants, modifier groups, multi-item carts, and item-level cancellations</li>
    <li>Fire-to-kitchen workflow that groups pending items by station into Kitchen Order Tickets and broadcasts them instantly to the KDS</li>
    <li>Per-station Kitchen Display System with item-level status tracking: pending, preparing, ready — with tap-to-advance on the Flutter app</li>
    <li>GST-compliant billing with CGST+SGST for intrastate and IGST for interstate, computed per line item, with a print stylesheet for 76mm thermal receipt printers</li>
    <li>Razorpay payment integration with HMAC signature verification on the server side, supporting cash, card, UPI, and split settlements</li>
    <li>Loyalty program with configurable point-earning rules and redemption as invoice discounts</li>
    <li>Zomato and Swiggy webhook ingestion with HMAC verification and idempotent order creation</li>
    <li>Analytics module with sales by date range, top items, hourly heatmap, GST report export, and table turnover metrics</li>
    <li>Auto-generated Swagger UI at /api/docs/ with an OpenAPI schema for all 40+ endpoints</li>
    <li>10 automated tests covering GST calculation, order-to-KOT-to-billing flow, Razorpay signature verification, and PIN login</li>
    <li>Demo seed data included — five roles, a full menu, tables, and zones ready to explore on first run</li>
  </ul>

  <h2>Who This Is Built For</h2>

  <p><strong>Agencies and software studios</strong> who get hired to build restaurant tech and need a production-ready codebase to start from rather than scaffolding everything from scratch. White-label this, skin it to the client's brand, and deliver in weeks instead of months. The <a href="https://startup.codeaj.com/services/customization">product customization and white-labeling service</a> at CodeAj Startup is available if you need help with that process.</p>

  <p><strong>Restaurant tech founders</strong> building a SaaS POS or a vertical SaaS for the food and beverage sector. The multi-tenant architecture patterns, RBAC, and aggregator integration are already in place. You are building on top of something solid rather than starting from zero.</p>

  <p><strong>Restaurant owners and operators</strong> who want to own their software instead of paying per-terminal licensing fees indefinitely. Deploy this on a ₹500/month VPS and run it forever. If you need someone to set it up for you, the <a href="https://startup.codeaj.com/services/deployment">cloud deployment and server setup service</a> covers end-to-end VPS configuration, SSL, domain, and CI/CD.</p>

  <p><strong>Developer teams at food-tech startups</strong> who want to onboard quickly onto a well-structured codebase. The source code walkthrough and developer onboarding service is available for teams who want a guided session through the architecture.</p>

  <h2>Real-World Applications and Use Cases</h2>

  <p>A standalone restaurant or QSR can deploy this as-is after environment configuration. The seed data command sets up a demo restaurant in one step, and the system is production-ready without modification for a single-outlet deployment.</p>

  <p>A cloud kitchen with multiple stations benefits directly from the per-station KDS setup. Each station — grill, cold prep, desserts — gets its own tablet showing only its tickets. The floor plan can be simplified or removed entirely for delivery-only operations.</p>

  <p>An agency building a white-label POS for a restaurant chain takes the codebase, replaces the brand identity, adjusts the feature flags, and ships a branded product to its client in a fraction of the time a ground-up build would take.</p>

  <p>A restaurant SaaS founder uses this as the foundation for a multi-tenant product. The restaurant ID is already threaded through every model and every WebSocket channel group. Adding tenant isolation at the database or schema level is a natural extension rather than a retrofit.</p>

  <h2>Why Buy This Instead of Building It</h2>

  <p>A mid-level developer in India costs between ₹50,000 and ₹1,20,000 per month. Building this system from scratch — the backend, the admin dashboard, the waiter app, the KDS, the WebSocket infrastructure, the GST billing engine, the Razorpay integration, the aggregator webhooks, the analytics module — would take one developer at minimum six to eight months of focused work. That is ₹3 to ₹10 lakhs in development cost before you write a single line of your own business logic.</p>

  <p>TableOS gives you all of that working code on day one. The architecture decisions are already made. The edge cases around GST computation, HMAC verification, and token refresh are already handled. You start from a working system and customize it for your specific use case instead of building infrastructure that already exists.</p>

  <p>This is what <a href="https://startup.codeaj.com">CodeAj Startup</a> is built for — shipping production-ready software products so founders and agencies can stop rebuilding the same foundations and start building what actually differentiates their product.</p>

  <h2>What You Get on Purchase</h2>

  <ul>
    <li>Complete source code for all four components: Django backend, Next.js admin dashboard, and Flutter mobile app (waiter mode + KDS mode)</li>
    <li>Full environment variable documentation and .env.example files for every component</li>
    <li>Database migration files and a seed management command for demo data</li>
    <li>Deployment guide covering local setup, VPS deployment with Nginx and Gunicorn, and production checklist</li>
    <li>API documentation auto-generated via drf-spectacular, accessible at /api/docs/ when the backend is running</li>
    <li>10 automated tests with instructions for running the test suite</li>
    <li>README files for all three directories: Backend, Frontend, and Mobile</li>
  </ul>

  <p>Optional add-on services available after purchase: custom product development, product customization and white-labeling, cloud deployment and server setup, ongoing maintenance and support, and source code walkthrough sessions. Visit the <a href="https://startup.codeaj.com/contact">contact page</a> to discuss any of these.</p>

</div>

roduction-ready restaurant POS with Django, Next.js dashboard, Flutter waiter app and KDS. GST billing, Razorpay, and Zomato/Swiggy included.

Restaurant POS System Source Code — CodeAj Startup

A production-ready restaurant POS with Django backend, Next.js dashboard, and Flutter apps for waiters and kitchen display. Razorpay, GST, and Zomato/Swiggy built in.

CodeAj Startup

Production-ready restaurant POS system with Django backend, Next.js admin dashboard, Flutter waiter app and KDS. Includes GST billing, Razorpay payments, Zomato and Swiggy webhook integration, and real-time WebSocket updates.

TableOS — Full-Stack Restaurant Operating System

A complete restaurant operating system with REST API, WebSocket real-time updates, floor plan management, kitchen display system, GST billing, and Razorpay integration. Built with Django 5, Next.js 16, and Flutter 3.

Home

Products

Food & Restaurant

You get the complete source code for all four components: the Django 5 backend with REST API and WebSocket server, the Next.js 16 admin dashboard, and the Flutter 3 mobile app which runs in both waiter mode and kitchen display mode. All environment files, migration files, seed data, tests, API documentation, and deployment guides are included.

What is included in the TableOS source code purchase?

Yes. You own the source code after purchase and can white-label it for your agency clients or as a standalone product. CodeAj Startup also offers a product customization and white-labeling service if you need help modifying features, branding, and workflows.

Can I white-label this restaurant POS and sell it to my clients?

Yes. The billing module computes CGST and SGST for intrastate transactions and IGST for interstate transactions, applied per line item. Invoices include a print stylesheet optimized for 76mm thermal receipt printers.

Does this support GST billing for Indian restaurants?

Yes. The aggregator module ingests webhooks from both Zomato and Swiggy with HMAC signature verification and creates orders idempotently in the system. A management command is included for simulating aggregator orders in development.

Does this work with Zomato and Swiggy orders?

The system ships with SQLite3 in WAL mode, which handles most single-outlet deployments well. The DB_PATH environment variable lets you point to any location on disk. For multi-tenant or high-concurrency production deployments, the Django ORM makes it straightforward to switch to PostgreSQL.

What database does TableOS use?

Yes. CodeAj Startup offers a cloud deployment and server setup service that covers end-to-end VPS configuration, SSL, domain setup, and CI/CD pipeline. Source code walkthrough sessions for developer teams are also available.

Your Details

TableOS — Full-Stack Restaurant Operating System with Waiter App, KDS, and GST Billing