Use cases
Your teams know the logic. Your applications need the results.
Business teams maintain pricing formulas, eligibility rules and cost models in Excel. XSheet turns a supported workbook into an API so applications can use that logic without developers recreating it. The team keeps working in Excel; changes are verified and approved before release.
Pricing and quoting
Calculate a quote from the model the business maintains.
A sales portal needs a price, but the formulas and discount tables are maintained in Excel. Turning that workbook into an API keeps the calculation available to each application that needs it.
- In the workbook
- The team maintains base prices, quantity breaks, configuration rules and discounts. Examples include manufactured products, service packages, freight tariffs and insurance premiums.
- In the application
- A quoting system sends the selected product, quantity and other named inputs. The API returns the calculated price and any components exposed by the workbook. Verify rounding, discount thresholds and representative quotes before approving a change.
Underwriting and eligibility
Return the outcome of rules defined in Excel.
A workbook can contain rules as well as arithmetic. Conditions and lookup tables can determine eligibility, set a limit or identify a case that needs a person’s review.
- In the workbook
- The model author defines the criteria and the outputs: for example, eligible, maximum coverage, referral required and a reason code. Those outputs must come from the workbook’s logic; XSheet does not generate explanations for a rule.
- In the application
- An underwriting or product application sends the relevant facts and receives the rule outcomes. It handles case assignment and the next action. Verify both sides of each threshold, exception cases and expected referrals before release.
See how this fits insurance underwriting and banking applications.
Financial calculations
Use the same financial model across applications.
A finance team can maintain a cash-flow or repayment model while customer portals and internal tools call its published version.
- In the workbook
- Formulas apply the model’s rates, fees, dates and assumptions. Depending on the workbook’s supported functions and features, outputs can include installment amounts, cash-flow tables or scenario totals.
- In the application
- A lending portal or planning tool submits an amount, term and scenario inputs. The API returns the defined values or tables. Check date conventions, rounding and expected schedules before approval; the business remains responsible for the model’s assumptions and use.
Commissions and incentives
Apply the approved compensation plan consistently.
Sales operations often owns the plan in Excel, while sales and payroll systems need its results. The workbook can supply those calculations through an API.
- In the workbook
- The plan defines targets, payout tiers, accelerators and split rules. Named outputs expose the total and any breakdown the model calculates.
- In the application
- A sales system sends transactions or period totals in the shape the workbook expects. The API returns calculated amounts for review or a downstream payroll process. Compare cases around tier boundaries and the effect of plan changes before release.
Costing and margins
Bring cost and scenario calculations into everyday tools.
Teams can maintain a cost model in Excel while a quoting or planning application supplies the assumptions for each calculation.
- In the workbook
- A manufacturing model combines materials, labor and overhead to calculate cost and margin. An energy model might use consumption, tariffs and project costs to estimate savings and payback. Each is a separate model with its own assumptions.
- In the application
- The calling tool sends a configuration or scenario and receives the workbook’s outputs. Your team supplies current costs and tariffs through model versions or API inputs. Test representative scenarios and review changed assumptions before approving a version.
Operational rules
Use workbook rules at the point a decision is needed.
A service or operations team may already use Excel to check combinations, assign a category or calculate an allowance. An application can call those same supported rules.
- In the workbook
- Conditions and tables define permitted product combinations, service eligibility, warranty allowances or processing categories. The author chooses which flags, amounts and labels the API returns.
- In the application
- An order or service system sends the relevant attributes and receives the calculated outcome. It manages documents, approvals outside model release, notifications and other process steps. Verify allowed and rejected cases, including exceptions, before changing the rules.
Assess the fit
Start with the workbook and the result your application needs.
These are illustrative applications, not customer case studies or claims that every workbook is supported. A use-case label does not establish compatibility or correctness.
- Can the logic run as a calculation?
- The application must be able to supply defined inputs and use defined outputs. XSheet serves the calculations and rules in the model. Your applications remain responsible for the surrounding workflow, external data and actions.
- Does XSheet support this workbook?
- Review its formulas, names, table shapes and Excel features. Unsupported features need assessment before the workbook can be used. Check the function catalog and include the actual model in your evaluation.
- What demonstrates that the results are right?
- Compare XSheet’s results with Excel’s saved values and test representative inputs with expected outputs. Include boundaries and failure cases. These checks provide evidence for the tested cases; business owners still validate the rules and assumptions.
- What does operating it require?
- Agree traffic, response-time and deployment requirements with engineering. Measure the chosen model on the intended hardware. Decide who owns model changes, approves releases and operates the customer-hosted installation.
XSheet
See how your model would work as an API.
Discuss the workbook your team maintains and the applications that need its results. Explore integration and deployment in your environment.