Change a business rule. Without filing a ticket.

Write your pricing, eligibility or fraud policy in plain English. SmartDecision turns it into a decision table your team can read and change, and your apps can call. It runs on your own servers.

Answers
Same inputs, same answer
Runs
On your servers
Data
Never leaves your network
Rules
Plain sentences your team can read

Timing Recorded from production Live

Four product decisions, answered by one production instance

Session
00:00
Requests
0
Answers
0
Best
-
Pos Req Decision Time Gap
1 -
2 -
3 -
4 -
5 -
6 -
7 -
8 -
9 -
10 -

Last request waiting for the first answers

    Each row is one request of 30 input sets to a production SmartDecision instance (Hetzner CX33, Falkenstein), timed with the network included. This replays a recorded session; run it live to time four requests from your browser.These requests were timed in your browser.

    One engine behind your product. Tickets. Checkout. Payments. Claims.

    In the demos, real products ask SmartDecision for every answer, from a 251-rule ticket price table to a five-step claims chain. Open one and change the rules yourself.

    See all six live demos

    One policy. Three forms.

    The sentence your team writes, the table it becomes, and the call your app makes.

    1 Written
    A loan is approved if credit score is 700 or higher, age is between 21 and 65, and income is at least €10,000. Scores from 650 to 699 go to manual review.

    As your team writes it. The built-in AI drafts the table on your server.

    2 Decision table
    credit-scoreageincomeloan-status
    >= 70021...65>= 10000Approved
    650...699**Manual Review
    ***Rejected

    * is any value. Checked top to bottom; the first match answers.

    3 API call
    POST /api/resolve/214
    credit-score = 712
    age          = 34
    income       = 18000
    {
      "output": {
        "loan-status": "Approved"
      },
      "rule": { "position": "1" }
    }

    The answer names the rule that matched, so every result can be traced.

    No AI at runtime. Same inputs, same answer, every time.

    Your policy is buried in code you can't read.

    Pricing tiers, eligibility checks, fraud thresholds, approval limits. Each one starts as a simple if and ends as nested logic nobody wants to touch. The people who own the policy can't read it, and every change waits in the engineering queue.

    SmartDecision moves the policy into a table its owner can read, test and change. Your code keeps one call.

    if (score >= 700) {
      if (age >= 21 && age <= 65) {
        if (income >= 10000) {
          return "Approved";
        }
      }
    } else if (score >= 650) {
      return "Manual Review";
    }
    return "Rejected";
    The loan policy above, the way it usually ships.

    Built to be trusted in production.

    Four things that keep a quick change from becoming an incident.

    Tests guard the policy

    Save the answers you expect next to the rules. Every edit is checked against them before you save.

    Example tests with the threshold lowered to 680
    InputExpectedGetsResult
    score 720ApprovedApprovedPass
    score 690Manual ReviewApprovedFail
    score 640RejectedRejectedPass

    Versions never break your apps

    Change a decision that has answered requests in a way that would break them, and saving makes a new version. Apps that don't ask for a version keep the old one until you retire it.

    SmartDecision-Version: 1
    SmartDecision-Latest-Version: 2

    One endpoint, any language

    Send inputs, get the answer and the rule that matched. Up to 2,000 input sets in one batch request.

    curl -X POST http://decisions.internal:8080/api/resolve/42 \
      -H "Authorization: sd_your_secret_key" \
      -d "credit_score=720" -d "age=34"

    Every change on the record

    The audit log keeps who changed which decision and when, next to the tests that say what it should answer.

    • Maria updated Loan approval
    • Maria added a test to Loan approval
    • Tom created Mortgage pricing

    Everything is in the license. No editions. No add-ons.

    Decision tables
    Typed inputs and outputs: number, string, true/false, date, time, date-time
    Comparators
    Equals, not equals, greater or less than, ranges, lists, * for any value
    Evaluation
    Deterministic, first match wins. No AI at runtime
    Impact preview
    Which answers change, for which inputs, before you save
    Decision tests
    Expected answers saved next to the rules, checked before every save
    Versions
    Breaking changes become a new version; pin one with SmartDecision-Version
    Resolve API
    POST /api/resolve/:id, or a batch of up to 2,000 input sets per request
    API keys
    A secret key per app
    Team
    Invite colleagues; unlimited users on every license
    Audit log
    Who changed which decision, and when
    Drafting
    Optional built-in AI on your own server, no GPU; or your own AI server
    Deployment
    One container, one install script; Linux amd64 or arm64
    Storage
    SQLite: your rules are rows in one file on your own disk
    Footprint
    1 vCPU and 512 MB RAM without the built-in AI
    License
    A signed key, checked offline on your server
    Updates and support
    Every release while licensed; email answered within two business days

    Install on any Linux server

    $ curl -fsSL https://get.smartdecision.io/install.sh -o install.sh
    $ sh install.sh

    The installer asks for your license key and how to draft decisions, sets up Docker if needed, verifies the download and starts SmartDecision. Installation guide

    Where does the data go? Nowhere.

    The rule engine, the console and the built-in AI that drafts your rules all run inside your network. Credit scores, transaction amounts and eligibility inputs never leave it, when you write a rule or when an app asks for an answer.

    Try it on your own server. With your own policies.

    A trial license is free, needs no card and has no feature limits. Keep your decisions when you buy.

    Press ? for keyboard shortcuts