Most founders treat tariffs like a weather report: something to brace for, complain about, and endure. But tariffs aren’t just a policy issue; they’re a data problem. And the faster you start thinking about them that way, the faster you can find leverage others miss.
At Izba, we recently built a Tariff Scenario Calculator, a public-facing tool that lets brands model the landed cost of different sourcing decisions under various tariff conditions. It didn’t take a dev team. It didn’t take months. We stood it up in a few weeks (despite our project lead breaking his wrist halfway through) using low-code tools, structured thinking, and clean data.
And the impact? It didn’t just save time. It changed the entire tenor of our conversations with clients. Suddenly, we weren’t just advisors. We were problem-solvers with a point of view and the infrastructure to back it up.
This article isn’t about tariffs. It’s about thinking through operational problems with clarity before throwing software at them. Because tools don’t solve problems, clarity does.
Tariffs Aren’t Just Expensive—They’re Confusing
Ask most early-stage operators what their tariff exposure is, and you’ll get vague answers like:
- “I know they have been going up.”
- “We probably need to look at another country.”
- “Tariffs were paused, so we aren’t super concerned about it now.”
What they’re saying is “we don’t know.”
Tariffs hit hard not because they’re high, but because, in the current environment, they are unpredictable and poorly understood. Many brands don’t know:
- What HTS code they’re using
- How duty rates differ by country of origin
- How freight rates differ by country of origin
- Where the break points are between different scenarios
And because they don’t know, they can’t plan. They can’t pivot. They can’t respond.
Tariffs are just one example. The real issue is this: your decisions are only as good as your data.
Tools Don’t Solve Problems—They Amplify Clarity
We’ve seen too many brands assume that buying software will magically fix their problems. But software doesn’t give you clarity. It reflects it. If your logic or data is fuzzy, your outcomes will be too.
So before we create a single piece of automation logic, we start by asking:
- What decision does the user need to make?
- What inputs are essential to that decision?
- What steps would we follow if we were doing this manually?
This became our blueprint. Not for the UI, but for the logic behind the tool. Only after mapping the human process did we layer on automation.
“We didn’t start with code. We started with questions.”
That’s the difference between building something useful and building something expensive that no one uses.
How We Built the Tariff Scenario Calculator in a Few Weeks
The old way to get tariff clarity would’ve looked like this:
- Hire a trade compliance consultant with specialized knowledge of the countries you want to compare
- Wait 3–4 weeks
- Get a spreadsheet that’s already outdated
- Still have to explain it to your team
We wanted something faster. Something reusable. Something our clients and the public could use.
So here’s what we did.
Step 1: Map the Logic
We defined a clear decision flow:
- User enters a product description (or HTS code)
- Identify the destination country and possible source countries
- Allow user to estimate freight rates
- Present a comparative scenario table with options (e.g., China vs. Vietnam vs. Mexico)
- Give user the ability to run “What If” analysis
Step 2: Build the Interface in Lovable.dev
We used Lovable.dev to create the front-end UI and structure the backend. This allowed us to quickly test input logic, validate assumptions, and iterate without code. It’s conversational, lightweight, and flexible—perfect for early builds.
Step 3: Structure the Data in Supabase
We used Supabase to store tariff rates, HTS mappings, and scoring logic. The database structure let us run calculations, log user queries, and enable custom scoring rules on the fly. We started with a simple lookup table, but will integrate it with a real time database as traction increases.
Step 4: Export to Parabola
For users who wanted deeper workflows like exporting results we built a Parabola export layer. This lets our internal team or clients automate what happens after a scenario is generated (e.g., kickoff a sourcing RFP, update a forecast).
The Result?
What used to take hours now takes a few clicks. We condensed dozens of hours of expertise into a 60-second flow. Not only is this a massive time saver, it's a conversation changer.
Why Most Ops Software Fails (And How We Avoided It)
If you’ve ever bought a shiny ops tool that ended up gathering dust, you’re not alone. Most software fails because people try to automate things they don’t actually understand.
Here are the three silent killers:
1. Dirty Master Data
If your supplier list doesn’t include countries of origin…
If your product catalog doesn’t have HTS codes…
If your freight costs aren’t centralized…
You can’t automate what you can’t structure.
2. Undefined Decisions
A surprising number of teams haven’t defined what a “good” sourcing decision even is. Is it landed cost? Speed? Margin? Resilience?
If you don’t define it, no tool will help you optimize for it.
3. No Single Owner
Automation breaks down when responsibility is fragmented. When marketing owns product data, ops owns vendor data, and finance owns shipping costs, nobody owns the outcome. Good tech only works when someone is accountable.
What Smart Operators Do Differently
We work with brands from $10M up to $400M+, and the ones who scale well all have a few things in common:
- They treat data as an asset, not an afterthought.
- They write decision logic on paper before trying to automate it.
- They simplify before they speed up. (ECRS)
- They measure automation by the extent to which it removes manual context.
In other words, they don’t chase AI or automation for its own sake. They pursue clarity and use tools to scale it.
“A great tech stack accelerates good thinking. It doesn’t replace it.”
That’s how you move from being reactive to tariffs, delays, and policy shifts… to using them as leverage.
Turning Insight Into Impact
Since releasing the calculator, we’ve seen a few unexpected outcomes:
- Prospective clients now say: “This puts you in a whole new light.”
- Partners use it to review and verify sourcing recommendations before an RFP.
- Internally, we use the same engine for client strategy work and AI agent prototypes.
But most importantly, we proved to ourselves that speed is no longer a barrier. In a world where policy changes can drop overnight, this kind of tool isn’t a luxury; it’s a necessity.
Conclusion: Solve the Right Problem First
If you’re a founder under $50M, here’s the playbook:
- Don’t buy a tool yet: Instead, sketch out what decision you’re trying to make.
- Get your data house in order: Know your HTS codes, suppliers, freight lanes, and costs.
- Prototype the logic manually: If you had to make this decision with pen and paper, how would you do it?
- Use lightweight tools to test the flow: Lovable, Supabase, Parabola, these are your sandbox.
- Only scale what works: Once it’s working, automate. Until then, keep it simple.
At Izba, we believe ops tools should make you feel more confident, not more confused. That’s why we start with clarity, and build from there.
Want help translating decisions into automation? That’s what we do.
Reach out or just try the calculator and see how a little clarity can change the conversation.
