Cadere · Software
Software factory.
We build for clients and we operate three products of our own, so the stack we recommend is the stack we tend to operate on.
The work we take
Custom builds
Most client work is a system someone needs and cannot buy off the shelf: a web or mobile application, a data pipeline, an internal tool that replaces a spreadsheet nobody trusts any more. We have led the enterprise migrations for customers with more than 200 sites, built engineering software used daily by tier 1 miners, and shipped Proof of Concepts (POCs) and Minimum Viable Products (MVPs) for startups in e-commerce, heavy industry and more. Cloud and database adoptions and migrations, and security work sit inside those builds rather than beside them, streamlining delivery.
Deciding what to build
This is the technology consulting half of the practice, and often the cheaper half. Before a build there is a decision: extend the system or replace it, move to the cloud or stay on-premises, buy the product or write it. We take that assessment as its own piece of work, covering what you already run, what it costs to hold, and where the security and licensing debt has collected. It sometimes ends with us recommending less software rather than more.
Companies we own and operate
The client work runs on the same agentic platform we built for ourselves: protocols, pipelines, and pods that compose applications and delegate work end-to-end. Alongside it we operate AI-native products in financial intelligence and listed-market monitoring.
How we use AI
AI, applied where it pays.
We ship AI-native systems for SMEs and enterprise teams, built on the agentic platform we own and operate. Working systems in production, measured in hours saved and margin gained. Not decks.
The platform was built with end-to-end tests and roughly 95% code coverage; our first product on it went from MVP in three months to a full product in six. We hold advisory work to the same bar, and we use our own tools on ourselves before we put them near a client.
Find the leverage
We map your operation to the handful of processes where AI genuinely pays, measured in hours saved and margin gained, agreed up front.
Build on our platform
Agentic protocols, pipelines, and pods on a platform we own and operate, so your solution ships in weeks.
Prove it in production
Every engagement ends with the same test: the system runs, the savings are on the ledger, the revenue is real.
How we deliver
Scope before quote
The first meeting is about the shape of the problem, not the shape of a proposal. Bring whatever exists: a brief, a spreadsheet, a competitor’s product, an attempt that stalled. You get back a plain reading of the technical requirement, including the parts you did not ask about and the parts you can drop. Nothing is priced until that is settled.
How the build runs
Every week or fortnight you get something running rather than a status report: a real URL, real data, and the current state of the thing you are paying for. Feedback is visibly applied to the product instead of with documents and emails describing it. Changes to scope are re-quoted in writing before they are built, so the number at the end is the number you agreed upon, leaving no surprises.
Send what you have
A paragraph by email is enough to start. Links, screenshots, a rough spreadsheet, or a half-written brief all help. A formal specification does not exist yet and does not need to.
One conversation
We work through the business problem before the software problem. If the honest answer is that you do not need a build, you hear it in that meeting rather than after an invoice.
Scope in writing
The requirement comes back to you on paper: what is in, what is deliberately out, and the assumptions the estimate stands on. Argue with it here, where changing it is free.
Fee and dates
A fixed fee against that scope, with the delivery dates and what lands on each one. You decide with the numbers in front of you.
Engagements
Most engagements start as one of five things. Each is quoted as a fixed fee against a written scope, so the way to get a number is to tell us what you need.
A new business, set up to trade
Name, logo, domain, email, website, and enough analytics to tell whether any of it is working. This is for a business in its first months, where being credible and live now beats being finished next year.
Web application
For the work a website cannot do: customer records, an internal workflow, a client-facing portal, anything with accounts and permissions behind it. Built on the stack listed below, which is the same one our own products run on.
Mobile application
One codebase across iOS and Android, sharing a data layer with the web version. We will say early if a responsive web app would do the same job, because an app store adds review cycles and update costs that a website does not carry.
Custom software
The builds with no category: instrumentation, data pipelines, software that encodes a process only your business runs, or a product with intellectual property in it. These get scoped from first principles, because there is no template to start from.
The first version of a product
A minimum viable product (MVP) is the smallest build that proves an idea earns money or attention, made to be replaced once it has. We shipped the MVP for one of our own products in three months and the full product in six, and we have built first versions for startups in e-commerce and digital assets. Starting small is what keeps stopping cheap.
The stack we run
Every tool below is in production in one of our own products or a client build, so we have already run it on ourselves before it goes near a client. The list is deliberately short. A smaller stack is cheaper to patch, faster to hand to your own team, and less likely to strand you with dependencies nobody maintains. Where a client already runs something else, we work in their stack rather than move them onto ours unless it benefits what they are building or is part of a modernisation strategy.
React
The rendering layer under nearly everything we ship, including all three products we operate.
Next.js
The React framework we build on: server rendering, routing, and caching in one place.
TypeScript
Static types across the whole stack, so refactors are safe.
Node
Server runtime for our APIs, background workers, and build tooling.
Material UI
Component library for consistent, accessible enterprise interfaces.
Tailwind CSS
Utility-first styling, with shadcn/ui where a product needs its own component layer.
Shopify
Commerce builds, storefront themes, and app integrations for clients who sell online.
Webflow
Marketing sites your team can edit without a development cycle.
Neon Postgres
Serverless Postgres with database branching, so a preview deploy gets its own data.
Prisma & Drizzle
Typed ORMs. Prisma where the schema leads, Drizzle where a lighter SQL-first layer suits.
Zod
One validation schema shared by the browser and the server, so they cannot drift.
Claude
Anthropic’s models do most of our generation, extraction, and analysis work.
Vercel AI SDK
Provider-agnostic model access, streaming, and tool calling.
Langfuse
Tracing and evaluation for AI features, so model behaviour is measured rather than assumed.
Firecrawl & Crawlee
Web data acquisition at scale, including pages that only exist after JavaScript runs.
Inngest
Durable background jobs and scheduled work that survive a deploy.
Stripe
Subscriptions, payments, and tax for the products we operate.
Auth.js & WorkOS
Authentication, from single-user sign-in to enterprise SSO and directory sync.
PostHog
Product analytics and feature flags, self-servable and privacy-configurable.
Vitest
Unit and integration tests, run on every push.
Playwright
End-to-end browser testing that keeps releases safe.
Vercel
Edge hosting, preview deployments, and rolling releases for our front ends.
AWS
Cloud infrastructure we build and host on.
Azure
Microsoft’s cloud platform for enterprise workloads.
Cloudflare
Edge network for DNS, CDN, and security.
Client work
We take selective development engagements for small and medium enterprises (SMEs) and enterprise clients: AI systems, advisory, and application development, built on our own agentic platform where it fits. We scope tightly, quote a fixed fee, and only commit to capacity we have. When we are at capacity, and for the most technically challenging problems, delivery goes to Deepsolve, our software principal delivery partner, an independent Australian firm working under our scope and review.
