Custom software development
We design, build and maintain custom software: web and mobile applications, websites and platforms, internal systems, integrations and APIs, plugins and extensions. A team assembled for the project, stages with acceptance criteria, code and infrastructure in your own accounts.
The first conversation is free: 30 minutes online, no preparation and no commitment.
What we build
We scope every project around the business process and its users, not around a feature list. Below are the kinds of solutions we deliver most often.
Web and mobile applications
Applications for customers and staff: customer portals, admin panels, PWAs that also work offline, mobile applications for iOS and Android. We run the architecture, backend and cloud ourselves; mobile interfaces are built with partners we have worked with for years.
Websites and platforms
Corporate sites, campaign pages, blogs and online shops; platforms serving many brands and markets on shared infrastructure. WordPress and static publishing, multilingual content, SEO, performance and accessibility confirmed by external reports. More under digital products & platforms.
Internal systems
Tools for processes that so far ran in spreadsheets and e-mail: order and document workflows, registers, warehouse, settlements, asset and access management. Reporting panels and dashboards on the data the company already has.
Integrations and APIs
We connect systems that share no common language: CRM, ERP, accounting, warehouse, e-commerce, payments, partner systems. We design and document APIs for customers and partners, webhooks, data synchronisation and system-to-system authentication.
Plugins, extensions and modules
Plugins for WordPress and other CMSs, extensions for the tools your team uses, modules for existing platforms, integrations with no-code tools. A smaller scope, the same standard: tests, documentation, an update plan.
Automation and operational tools
Command-line tools, workers and task queues, CI/CD pipelines, document generators, monitoring and reporting. We turn repeatable work into processes that run without a person, using AI and automation where it makes sense.
Who it is for
Companies without an IT department
Processes run in spreadsheets and e-mail need a system, but the company has no team to build it and nobody to verify a vendor's offer. We run the whole thing: from needs analysis, through delivery, to maintenance.
Companies whose IT team is busy with operations
The team keeps the production systems running and has no capacity for a new project, integration or application. We join as a team for the length of the project, work to your standards and hand over code your engineers will keep developing.
Organisations with an unsupported system
The application has run for years, the vendor is no longer available, the documentation is incomplete, and the company uses the system every day. We take it over, stabilise it and develop it without interrupting the organisation's work.
Taking over and modernising existing systems
We propose a rebuild from scratch only when the current system blocks the company's goals. Otherwise we work on what already runs.
Audit
A review of the code, infrastructure, access, backups and dependencies on external services. The result: a prioritised list of risks and an action plan that stays with the company whoever carries it out.
Stabilisation
Recovery of access and code, a repository, a test environment, backups with a tested restore, monitoring. Only then functional changes.
Modernisation
Technology upgrades, splitting out modules, migration to the cloud or to static publishing, new integrations. In stages, with a working system after each one. The environment is described under cloud & infrastructure.
How we work
A team for the project
The core of the team is the founders: architecture, infrastructure, security, project management and UX. Web and mobile developers, DevOps, analysts and designers come from a network of partners we have worked with for years. You pay for the team the project needs, not for headcount.
In your accounts and your repository
From day one the code lives in your repository, the infrastructure in your accounts, the domains and access in the company. Changing vendors never means recovering anything.
Stages with acceptance criteria
Every stage has a scope, a price and acceptance criteria agreed before it starts, and a working version to check when it ends. After each stage you decide whether we continue.
AI at work, under control
We use AI tools in analysis, code and documentation, under an engineer's supervision and with code review. Project data stays in tools that do not train models on it, and every result has an owner and acceptance criteria.
Typical situations at the start
The same patterns repeat in most projects that reach us:
- A request for proposal that lists features instead of describing the problem, so every vendor prices a different scope.
- Code and access held by the previous vendor: the company has no repository and no passwords to its own systems.
- Systems joined by hand: once a week someone retypes data from one into another.
- No test environment, so every change goes straight to production.
- A contract with no acceptance criteria and no clause transferring the rights to the code.
- A project priced in full up front, before anyone checked whether the first version is needed in that shape.
Most of them are solved by one well-run analysis stage before the delivery is priced. When a device of your own or an unusual production process is involved, see R&D & devices.
The founders' experience
Projects delivered by the founders before the company was founded, directly and with agencies, for startups, agencies and large organisations, including healthcare, FMCG, e-commerce, telecommunications, aviation, insurance and electromobility. More under achievements.
- 25+ tools and automations of our own: static publishing, forms, consent and cookies, monitoring, machine management panels, task synchronisation.
- 100+ virtual machines and 250+ cloud projects under one supervision, in one model of roles and permissions.
- A technical team of a few people running dozens of sites: scale comes from architecture and automation, not headcount.
- Access for the client, agencies and media houses organised in one system.
- 6+ years without a security incident on the platforms we run.
Example: tools instead of headcount
A typical starting point and the solution built from it. The client's name, figures and details are discussed in a meeting.
Before
Dozens of sites and integrations handled by hand: publishing through a developer, access granted by e-mail, machines running around the clock, outages noticed by users. Every new site added work for the team.
After
Our own tools instead of manual work: static publishing, forms and consent from one configuration, a panel for machines that run only during working hours, monitoring with automatic health checks, task synchronisation between systems.
Result
A team of a few people runs dozens of sites and 100+ machines from one panel. Infrastructure and operations costs down by 80% while the number of sites and integrations kept growing. Every tool has documentation and an owner inside the company.
Three steps, each of which can be the last
Free consultation
30 minutes online. You describe the process or system you want to build or take over, who uses it and what already exists. We say where we would start, whether it is a project for us and what team it needs. No preparation and no commitment.
Analysis and estimate
Fixed scope and a fixed price agreed before the start. A map of the process and systems, the scope of the first version with priorities, the architecture, a split into stages with acceptance criteria and a delivery estimate. We go through the result with your team.
Delivery and development
Built in stages: working versions to check, tests, launch and handover. After launch, an agreed monthly scope of development and maintenance, or a handover to your own team.
What the analysis includes
- A map of the process and systems: who does what, where the data lives, what is retyped by hand.
- The scope of the first version with priorities: what goes in now, what later, what never and why.
- Architecture and technology with reasons, including what stays from the current systems.
- A split into stages with acceptance criteria and a price for each stage.
- An operating model after launch: who administers, who owns updates, backups and monitoring.
This is what a fragment of a delivery plan looks like. The data is illustrative, the layout is real:
| Stage | Scope | Time | Acceptance criterion |
|---|---|---|---|
| 1. Regaining control | Repository, access, backups, test environment | 2 weeks | Every change tested before production, restore from backup verified |
| 2. Orders | Order intake and status panel, accounting integration | 4 weeks | Orders reach accounting without retyping, a new order handled in under 2 minutes |
| 3. Warehouse | Stock, reservations, shortage alerts | 3 weeks | System stock matches the stocktake, zero manual spreadsheets |
| 4. Customer portal | Customer account, order history, documents | Version 2 | Deferred: decision after 3 months of stages 1–3 in use |
The analysis also works as the basis for a quote from another vendor: the scope, architecture and acceptance criteria stay with the company whoever builds.
What stays on your side
We work in your accounts, on your domains and in your repository. The system, the data and the access belong to the company, not to the vendor.
- Source code, configuration and documentation in your repository, with instructions for running and deploying it.
- A test environment, backups and monitoring that keep working without us.
- The transfer of rights to the code written into the contract, an NDA and a data processing agreement before the first access.
- Knowledge transfer to your team, as workshops if needed, or an agreed monthly scope of development and maintenance.
Technology follows the task
We choose it for the problem and for the team that will maintain the system. If you have your own technology stack, we work within it.
- Web and backend: JavaScript and TypeScript (Node.js), Python, Go, HTML and CSS, Bootstrap, PWA.
- Websites and CMS: WordPress, static publishing, our own plugins and themes.
- Mobile: iOS and Android with partners; PWAs on our own.
- Cloud and operations: Google Cloud Platform, Firebase, Cloudflare, Kubernetes, Linux, CI/CD, monitoring.
- Devices: Raspberry Pi and microcontrollers when the system touches the physical world.
FAQ
Are you a new company?
The company is, since 2026; the practice is not. Jakub has signed contracts in his own name since 2009, has run a business since 2016 and large digital environments since 2014; Agata has run digital projects for more than ten years. The tools and documentation of the previous decade were brought into the company under copyright transfer contracts. The timeline is on the founders page.
Are you a software company or a consultancy?
Both: we design and we build. The core of the team is the founders, who write code and run infrastructure themselves, and on larger projects we bring in specialists from the partner network. We do not broker developers.
Do you build mobile applications?
Yes. We run the backend, APIs, architecture and cloud ourselves; the iOS and Android interfaces are built with partners we have worked with for years. When the scope allows, we propose a PWA: one codebase for every platform, with no app stores.
Do you also take on smaller jobs, such as a plugin or a single integration?
Yes. A CMS plugin, an integration between two systems or a tool for one department is a project of weeks, run to the same standard: scope, acceptance criteria, tests, documentation, code in your repository.
How large are the projects you run?
From a tool for one department built in weeks to a platform run and developed for years. The common ground: a scope agreed before the start and stages that can end at any point.
Do you work with our IT department?
Yes. We can be a team for the length of the project working to your standards, take over a clearly defined part, or run the whole thing and hand it over after launch. The split of responsibility is written down before the start.
What about the system we already have?
An audit first: code, infrastructure, access, backups. Then stabilisation, and only then changes. We propose a rebuild from scratch when the current system blocks the company's goals, not merely when it gets in the way.
How do you bill?
First consultation: free, 30 minutes online. Analysis: fixed price. Delivery: stages with acceptance criteria and a price agreed for each stage. Development and maintenance: a monthly scope agreed after handover.
Who owns the code and the data?
You do. The code goes to your repository, the systems run in your accounts, and the transfer of rights is written into the contract. Before any access to data we sign an NDA and a data processing agreement. How contact-form data is processed is described in the privacy policy.
Tell us about the project
Write what system you want to build or take over, who uses it and what already exists. We will propose a time.
The first conversation is free: 30 minutes online, no preparation and no commitment.