Custom software development services, built around how your business works
We design, build and operate the software your teams and customers depend on: internal tools, customer portals and enterprise systems. Discovery takes one to three weeks and ends in a written scope with a fixed budget, before any code is written.
A written scope and a fixed budget before any work is billed.
What you are buying when you buy custom software
Custom software is written for one organization: its data, its approvals, its exceptions. Most clients come to it after a packaged product has stopped fitting. The team keeps a spreadsheet next to the system, copies records between two tools by hand, or works around a step the vendor will not change.
We take the whole engagement. One team runs discovery, designs the interface and the architecture, writes the code, sets up the cloud infrastructure and runs the system after launch. You work directly with the engineers building it, and the same people are answerable for it a year later.
If you are still deciding whether to build at all, our article on custom software versus off-the-shelf goes through that choice. This page is for the step after it, when you are choosing who builds. If the product is something you will sell by subscription, start with SaaS development.
Sound familiar?
The spreadsheet has become the system
Orders, approvals or stock live in a shared sheet that two people fully understand, and every month-end depends on both of them being in.
Someone copies the same record into two tools
The CRM and the ERP do not talk, so a person re-keys data between them. The mistakes surface weeks later as an invoice nobody can reconcile.
The step that matters is the one the vendor will not build
The product you license does most of the job. The part that makes your process different is the part their roadmap keeps postponing.
Customers phone to ask what a portal could show them
Order status, documents and invoices sit inside your systems, so your team spends its day answering questions customers could answer themselves.
What we build
Most custom software projects fall into one of four kinds, and each is scoped around the problem in front of you.
Internal tools
Workflow, operations and reporting systems for your own teams: approvals, scheduling, field work and the back-office screens that replace the spreadsheet.
- Workflows
- Approvals
- Reporting
Customer portals and platforms
Portals, dashboards and applications your customers sign in to, so they can see orders, documents, invoices and status without calling you.
- Accounts
- Self-service
- Documents
Enterprise systems
Role-based access, audit trails and compliance-aware architecture, with support commitments that run for years.
- Roles
- Audit trail
- SSO
Products for market
Software you will sell, with accounts, billing, roles and an admin panel. The SaaS development page covers this kind of build in detail.
- Billing
- Multi-tenant
What you keep at the end
Everything below is yours from the first commit, under your own accounts wherever possible. Nothing in it is licensed from us, and nothing can only be maintained by us.
your-company/
- docs/requirements.mdThe written scope from discovery, and the fixed budget it was priced at.
- docs/architecture.mdThe system diagram and the data model, kept current as the system changes.
- src/Every line of code, in a repository under your account from the first commit.
- tests/The automated test suite that runs on every change before it can ship.
- infra/The cloud setup and the CI/CD pipeline, in your own cloud accounts.
- docs/runbook.mdHow to deploy, roll back and restore, written so another team could run the system.
Four stages, and what
each one hands you
Every stage ends in something you can review and keep, including the stages that come before any code is written.
Discovery and requirements analysis
We map the real problem before any code is written: stakeholders, constraints, existing systems, and what success means in measurable terms.
- requirements.md
- scope + fixed budget
- risk register
Design and architecture
Interface flows and system architecture designed together, so what we specify is what we can build and scale.
- clickable prototype
- system diagram
- data model
Build, with a weekly demo
Short delivery cycles with visible progress. You review working software throughout, not a finished system revealed on launch day.
- staging deploy / cycle
- test suite + CI
- weekly demo
Launch, then operations
We deploy the system, monitor it, and hand over the runbook. We then continue to operate it under a monthly agreement you can end with 30 days’ notice.
- production infra
- runbook + handover docs
- monitoring + alerts
Terms we put in writing
before work begins
The figures we commit to on every engagement. Your project gets its own dated plan on top of them.
- Inquiry
- 1 business dayA reply from someone who has read the brief.
- Discovery
- 1 to 3 weeksEnds in a written scope and a fixed budget.
- Weekly review
- Every weekThe work as it stands, on a link you can open yourself.
- First release
- 8 to 16 weeksTypical time from the end of discovery to production.
- Operations
- 30 days’ noticeMonitoring and iteration under a monthly agreement.
Illustrative. Every project receives its own dated plan before work begins.
How the price of custom software is set
We do not quote from a first call. Discovery produces the written scope, and the scope is priced as one fixed figure before any build work starts. If the budget and the scope cannot meet, you hear it in the first conversation, before anyone has spent weeks on it.
- 01How many user roles and distinct workflows the system has to support
- 02How many existing systems it connects to, and what their APIs allow
- 03Whether you need a web application only, or web and mobile
- 04The data you bring with you: its volume, its quality and how many sources it comes from
- 05Compliance and audit requirements in your industry
- 06How much of the operation you want us to run after launch
What we build it with
Tools with long support horizons and large talent pools, so the system stays maintainable by any capable team, not only ours.
Next.js
Server-rendered screens that stay fast on an old laptop in a warehouse as well as on a new phone.
TypeScript
One type system from the database row to the screen, so a renamed field breaks the build instead of production.
Node.js
Backend services and APIs in the same language as the interface, reviewed together.
PostgreSQL
The database under almost every system we build, chosen because it will outlast the application on top of it.
Questions buyers ask us
The ones that come up most in first conversations about this service.
Something not covered here?
Email us at hello@kodfabrika.com.
Related services
Built to last.
Started this week.
Tell us what you’re building. You’ll receive a written scope, a defined budget, and a delivery plan. Not a proposal deck.