Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Restaurant POS Engineering Kit

    1

    Engineering kit for building resilient restaurant POS systems with offline sync, KDS routing, and financial precision.

    $7.29

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Restaurant POS Engineering Kit

    Restaurant POS Engineering Kit

    Example session with this skill installed

    Design a split-payment logic for a table order where three guests want to pay different amounts, ensuring no over-collection and idempotent retries.

    • Read your context and instructions
    • Compiled the restaurant pos engineering

    I have designed the split-payment logic based on the Order Account Payment skill. This implementation separates entities for tracking and uses transactional allocations to prevent over-collection.

    Split Payment Implementation Design

    // Core Entities for Payment Allocation
    interface Order {
      id: string;
      totalAmount: number;
      status: 'OPEN' | 'PAID' | 'PARTIAL';
    }
    
    interface Payment {
      id: string; // Idempotency key (provider ref)
      amount: number;
      status: 'PENDING' | 'COMPLETED' | 'FAILED';
    }
    
    interface PaymentAllocation {
      id: string;
      orderId: string;
      paymentId: string;
      allocatedAmount: number;
    }
    
    /**
     * logic: processPayment
     * 1. Start transaction
     * 2. Check current total allocated for orderId
     * 3. Verify (sum(allocatedAmount) + newAmount) <= order.totalAmount
     * 4. Record Payment with idempotency check on provider reference
     * 5. Create PaymentAllocation record
     * 6. Update Order status
     * 7. Commit
     */
    
    ComponentResponsibility
    IdempotencyPrevents duplicate charges if the network retries the payment command.
    ValidationEnsures the sum of PaymentAllocation never exceeds the Order total.
    ConcurrencyUses versioned aggregates to handle two waiters closing the same bill.

    Next steps

    1. Implement the PaymentAllocation database schema with a check constraint on total amount.
    2. Integrate the external payment provider SDK using the paymentId as the idempotency key.
    3. Add a specialized audit log for "Adjustments" to handle partial refunds without deleting records.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Building a production-grade restaurant POS requires more than a simple CRUD app. You need to handle concurrent payments, complex inventory math, and offline edge synchronization without losing data. This engineering kit provides the logic and architectural patterns to build a resilient, high-speed point of sale system.

    What it does

    • Payment Lifecycle handles split checks, idempotent payment commands, and balance calculations across orders and accounts.
    • Inventory & Recipes manages ingredient conversions, waste tracking, yield factors, and historical price snapshots.
    • Interactive Floor Plan manages table states, mergers, and transfers while preserving active sessions and order data.
    • Offline Edge Sync enables branch operation during WAN outages using local authority servers and outbox/inbox patterns.
    • KDS Routing distributes kitchen tickets to specific stations based on preparation rules with persistent state recovery.
    • Hardware Integration manages ESC/POS thermal printing queues with local agents and model-specific capability profiles.

    How it works

    1. Initialize Context by loading project ADRs and module contracts into the agent session.
    2. Select Domain choose between backend financial logic, frontend touch UI design, or gastronomy rules like modifiers and combos.
    3. Execute Procedures follow step-by-step logic for tasks like concurrent check closing or ingredient unit conversion.
    4. Validate Output verify implementations against strict acceptance criteria for idempotency and data integrity.

    Frameworks & tools

    The kit focuses on architecture and logic suitable for TypeScript/Node.js, React/PWA for frontends, and SQL-compliant databases using NUMERIC types for financial precision. It utilizes ESC/POS for hardware and TCP/IP for local network communication.

    Why this beats prompting it yourself

    Generic prompts fail at the edge cases of POS systems like race conditions in table transfers or precision loss in recipe scaling. This kit enforces specific patterns like versioned aggregates and outbox-based notifications that prevent double-charging and inventory drift.

    Use cases

    • Building a multi-station KDS that remains operational when the internet drops.
    • Implementing complex "split by item" or "split by person" payment logic.
    • Automating inventory deductions from 750ml bottles using fractional unit bases.
    • Designing a high-speed touch UI that prevents accidental double-taps on orders.

    Known limitations

    Does not provide executable binary drivers for printers. Requires a backend capable of supporting transactional integrity and outbox patterns. Logic is designed for structured POS environments.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for APIs & Backend.

    Requires backend support for transactional outbox patterns. No raw binary drivers included. Logic assumes a centralized authority or Edge server architecture.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 11 days ago

    Software
    Python

    Permissions

    Terminal / Shell
    Browser
    Read Files
    Write Files
    Listed11 days ago

    What's inside

    Frequently Asked Questions

    This kit provides the architectural blueprints, state machine logic, and data handling patterns required to build a production-grade system that handles complex edge cases like offline synchronization and financial race conditions.

    The kit is designed for use with advanced LLMs like GPT-4 or Claude 3.5 Sonnet, and it is compatible with IDE-based AI agents that support context-loading through ADRs and system prompts.

    You will receive a structured package of architecture decision records (ADRs), module contracts, logic procedures for complex domain tasks, and validation criteria for financial integrity.

    While the kit provides the logic for hardware communication protocols like ESC/POS, you will need to provide your own local drivers or bridge services to interface directly with physical thermal printers.

    The kit uses the outbox/inbox pattern and local authority server logic, allowing your POS to process transactions locally and sync back to the cloud once the connection is restored without data loss.

    The kit is optimized for modern full-stack environments, specifically TypeScript/Node.js for logic, SQL databases for financial precision, and React or similar frameworks for the frontend UI.

    New in APIs & Backend