When several conditions apply at once, the dose is decided by rules, not guesswork.
A multi-condition dose adjustment engine for an allergy treatment application. It resolves which adjustment applies when several patient conditions are present at once, against a defined priority framework, and every decision can be traced.
- Condition rules
- Multi
- Priority framework
- 1
- Every decision
- Traceable
- Source code yours
- 100%
The starting point
One condition is a lookup. Several at once is a correctness problem.
An adjustment rule for a single patient condition is easy to write down. When several conditions are present together, rules can conflict, and the application has to decide which one wins, the same way every time.
Before
Combined conditions had no clear answer
- Adjustment rules written one condition at a time
- No defined order when conditions overlap
- Hard to show why an adjustment was chosen
After
One rules engine with a defined order
- A priority framework decides between conditions
- The same inputs always give the same adjustment
- Every decision traced back to its rule
What we built
A dose adjustment engine, engineered as a correctness problem.
A rules engine inside the allergy treatment application that evaluates a patient's conditions together, applies the priority framework and records why each adjustment was chosen.
Scope of build
- Condition rules Each patient condition and its dose adjustment, defined as explicit rules. In scope
- Priority framework A defined order for resolving adjustments when conditions are present together. In scope
- Dose adjustment The resulting adjustment, calculated the same way every time. In scope
- Decision trail A record of which rules applied and why, for every adjustment. In scope
Delivery approach
Built around the clinical rules, with the edge cases worked out first.
- Discovery Map the conditions, the rules and how they interact.
- Build Develop the engine and the priority framework.
- Testing Check combined conditions against the expected adjustments.
- Rollout Release inside the application and support it in use.
Results & impact
The answer is the same every time, and it can be explained.
Combined patient conditions resolve to one adjustment through a defined order, rather than through case-by-case judgement buried in the code.
Because every decision records the rules behind it, the logic can be reviewed and changed with confidence.
Clinical logic, shipped as a rules engine you can audit.
-
Defined
Priority framework
One order for resolving overlapping conditions.
-
Consistent
Dose adjustments
The same inputs always give the same result.
-
Traceable
Every decision
Each adjustment shows the rules that produced it.
-
100%
Code & IP ownership
Source code and documentation handed over to the client.
Who it's for
We work best where the rules are complex and getting them wrong matters.
You're a strong fit if
- Health apps with clinical or dosing rules
- Products where several conditions interact
- Teams that need every decision explained
- Rules that change and must be maintained safely
We're not the right fit if
- Simple calculators with a single input
- Apps without rules that need explaining
- Projects looking for an off-the-shelf template
- You don't need custom logic or integrations
The commercial picture
Milestone priced, scoped before code, source code yours.
Commercial summary
The engine was built against agreed milestones, with the rules confirmed before code and the finished logic handed over in full.
-
Staged
Rules confirmed and built in agreed stages.
-
Visible
Test results shared as each part was completed.
-
Yours
Source code and documentation handed over.
The next step is a rules session, not a sales call.
We map your conditions, your rules and the edge cases where they meet, then scope the build around it.
Tell Us What You Are Trying To Ship
Thirty Minutes With Our Engineers On The Problem, The Constraints And The Realistic Shape Of A Build. No Pitch Deck.
