I Built a Free Supplement Stack Checker That Detects 102 Interactions
If you take more than one supplement, you might be unknowingly creating problems. Iron blocks zinc absorption. Calcium competes with magnesium. Vitamin E at high doses can thin blood dangerously when combined with fish oil.
I built a free tool to catch these issues before they happen: a Supplement Stack Checker that analyzes combinations of supplements and flags interactions, absorption conflicts, and timing issues.
Why I Built This
I work on Botánica Andina, an evidence-based resource about medicinal plants and supplements for Latin American audiences. While building our herb-drug interaction checker, I realized there was a gap: people taking multiple supplements had no easy way to check if their “stack” was safe.
The problem is real. A 2023 survey by the Council for Responsible Nutrition found that 75% of U.S. adults take dietary supplements, and the average user takes 3-4 different products. But most people never check for interactions between them.
Existing tools either focus on drug-drug interactions (ignoring supplements entirely) or are locked behind paywalls. I wanted something free, fast, and focused specifically on supplement-supplement interactions.
How It Works
The architecture is deliberately simple — everything runs client-side in vanilla JavaScript. No frameworks, no build step, no backend API calls. Here’s why:
The Data Layer
The core is a JSON database of 78 common supplements with 102 documented interactions. Each interaction has:
{
"supplement_a": "iron",
"supplement_b": "zinc",
"type": "absorption_competition",
"severity": "moderate",
"mechanism": "Both compete for DMT1 transporter in the intestinal lumen",
"recommendation": "Take at least 2 hours apart",
"sources": ["J Nutr 2003;133:1S", "Am J Clin Nutr 2005;81:S"]
}
Every interaction is sourced from peer-reviewed literature — primarily from PubMed, the Natural Medicines database, and systematic reviews. No blog posts, no anecdotes.
The Matching Algorithm
When a user selects their supplements, the checker runs pairwise comparisons across the selected set. For a stack of N supplements, that’s N×(N-1)/2 pairs to check.
function analyzeStack(selectedSupplements) {
const warnings = [];
for (let i = 0; i < selectedSupplements.length; i++) {
for (let j = i + 1; j < selectedSupplements.length; j++) {
const interaction = findInteraction(
selectedSupplements[i],
selectedSupplements[j]
);
if (interaction) {
warnings.push({
pair: [selectedSupplements[i], selectedSupplements[j]],
...interaction
});
}
}
}
return warnings;
}
Timing Optimization
Beyond just flagging conflicts, the tool suggests optimal timing. Some supplements are better absorbed on an empty stomach (iron, zinc), while others need fat for absorption (vitamins A, D, E, K). The timing engine groups supplements into morning (with food), morning (empty stomach), evening, and bedtime slots.
Zero Dependencies, Single File
The entire tool — HTML, CSS, JavaScript, and data — ships as a single HTML file under 60KB. No external requests, no tracking scripts, no cookies. It loads in under 1 second on a 3G connection.
This wasn’t just a design preference. For our Latin American audience, many users are on mobile with limited data plans. Every kilobyte matters.
Interesting Findings from the Data
Building the interaction database surfaced some surprising patterns:
1. The “healthy” stack can backfire. A common wellness stack — Vitamin C + Iron + Calcium + Zinc — has three conflicts: Calcium blocks iron absorption by 50-60%. Zinc and iron compete for the same transporter. Only Vitamin C + Iron is genuinely synergistic (C enhances iron absorption by 2-3x).
2. Fat-soluble vitamins compete. High-dose Vitamin A reduces Vitamin D absorption, and vice versa. Taking a multivitamin with separate vitamin D drops can reduce effectiveness of both.
3. Timing solves most problems. 70% of the interactions in our database can be mitigated by simply separating doses by 2+ hours. The issue isn’t that you can’t take both — it’s that you shouldn’t take them together.
Technical Decisions
Why not a database/API? For a tool this size, a backend adds latency, hosting costs, and a failure point. The entire interaction database fits in ~15KB of JSON. Client-side matching runs in under 5ms even on old phones.
Why vanilla JS? The tool does one thing. React/Vue/Svelte would add 30-100KB of framework code for zero benefit. The DOM manipulation is straightforward — render a list of supplements, handle clicks, display results.
Why not use an LLM? Accuracy. For health-related tools, deterministic lookups against curated data are safer than probabilistic language model outputs. Every interaction in our database has citations. An LLM might hallucinate an interaction that doesn’t exist, or worse, miss one that does.
What I Learned
-
Single-file tools are underrated. No build step, no deployment pipeline, no infrastructure costs.
scp index.html server:and you’re live. -
Health data curation is the hard part. Writing the code took 2 days. Curating and verifying 102 interactions against primary literature took 2 weeks.
-
Simple tools get shared. Our interaction checker gets 10x more organic traffic than any blog post. People link to tools. They bookmark tools. They don’t bookmark articles.
Try It
- Supplement Stack Checker — check your stack now
- All Health Tools — herb-drug interactions, caffeine calculator, pregnancy safety checker, and more
The tool is free and always will be. If you find an interaction we’re missing, or spot an error, I’d love to hear about it.
This is part of Botánica Andina, an evidence-based resource about Andean medicinal plants and natural health for Latin American audiences.
