We build in-house
Products are designed and shipped by our own team, not outsourced or assembled from acquisitions. We own the code, the infrastructure and the decisions.
Deterministic Strategies Inc. · Canada
Startups are probabilistic. The way we build them isn’t.
We are a holding company that builds, tests and operates new software products. Every product starts as a bounded experiment, with a written thesis, a budget and stop criteria agreed before work begins. AI-assisted engineering lets a small team run more of those experiments. The ones that show real demand become companies.
What we do
One group, many products, one way of building them.
Deterministic Strategies starts, funds and runs software products inside a single holding company. Products range from developer tools and infrastructure to open protocols and end-user applications. They share a process, an engineering standard and an operating backbone.
We test with real users
Each product gets a thesis, a budget and a stop date before work begins. Working software goes to the people it is for as early as possible, and we measure what they actually do.
We operate what works
Products that clear the bar become standalone companies within the group, with a dedicated team. Shared finance, legal, security and infrastructure come with them.
Why “deterministic”
Outcomes are uncertain. The process doesn’t have to be.
Most new products fail, and nobody can reliably predict which ones will work. What can be controlled is everything around the bet: how ideas are chosen, what each experiment is allowed to cost, how results are measured and when a project stops.
We make those parts explicit and repeatable. Criteria are written down before the first line of code, so each experiment ends in a decision rather than a debate. A stopped project is still useful: its research, components and lessons go back into the platform the next product starts from.
How we work
Four steps, applied to every product.
-
01
Thesis
Write down the problem, who has it, what they do about it today and what evidence would prove us wrong. Set a budget and a decision date before any code exists.
-
02
Build
Build the smallest version that can test the thesis with real users. It ships with the same tests, code review and security checks we expect of any production system.
-
03
Measure
Put working software in front of the people it is for. Track usage, retention and willingness to pay against the criteria from step one, not against how the team feels about it.
-
04
Decide
Continue, change direction or stop. Every outcome is written up. Reusable libraries, infrastructure and research move into the shared platform.
How we use AI
AI lowers the cost of building software. It doesn’t lower the bar.
We use current AI models throughout the engineering process, and we are specific about where. Models do much of the implementation work. People decide what is worth building and verify that it works.
What models do
- Write and refactor code against specifications and tests
- Generate test cases, fixtures and first drafts of documentation
- Review changes for bugs and security issues, alongside human review
- Summarize research: standards, prior art, public documentation and interview notes
What people own
- Which problems to pursue, and when to stop
- Architecture, data models and security boundaries
- Every change that reaches production, behind tests and CI
- Conversations with customers, partners and investors
The practical effect: a small team can test more ideas, at a lower cost per experiment, and stop the ones that aren’t working sooner.
Standards
What stays the same across every product.
Written decisions
Significant product and technical decisions are recorded with their context and the alternatives considered, so they can be reviewed and reversed.
Reproducible builds
Pinned toolchains and dependencies, committed lockfiles and CI gates on every change. What we test is what we ship.
Security from the first commit
Threat models, dependency audits and least-privilege access start with the prototype, not with the first enterprise customer.
Open standards
We build on open protocols and formats where they exist, and publish specifications when we create new ones.
Claims we can back up
Product pages, documentation and investor updates describe what the software does today, not what it might do one day.
Long-term ownership
As a holding company we don’t work to a fund’s exit timeline. Products are built to be run and maintained for years.
Work with us
Who we like to hear from.
Investors
If you invest at the earliest stages, we’re glad to walk through how we choose, test and stop experiments, and what is in progress now.
Founders and operators
Experienced builders who want to lead a product that has already passed early validation, with engineering and infrastructure support from day one.
Early customers
Teams willing to use early versions and tell us what’s missing. Design partners work directly with the people building the product.
Partners
Companies with distribution, data or domain expertise, where building something together makes more sense than building it alone.
Contact
Get in touch.
Tell us who you are and what you’d like to discuss. Messages from this form go directly to our team.
Prefer email? contact@deterministicstrategies.com