Understand · Build · Connect
Software development, AI
and process automation.
Consulting, applications, AI and automation — with clear deliverables, integration and verification.
From problem to product
What we can build for your business
Development and technical consulting for applications, AI, automation and interactive products. We can clarify feasibility, build the solution or extend an existing system — with deliverables and checks agreed for the project.
One workflow, not a mandatory package
Understand the problem
We clarify the context, users and result you need.
Build and integrate
We connect the interface, data and business rules in a usable solution.
Verify and hand over
We agree checks, document the work and prepare handover.
Choose your starting point
Services at a glance
Development, integration and technical consulting. Choose the area relevant to your project — services can be combined.
Build and modernise
Application development and modernisation
We build web applications and product modules, extend platforms and modernise existing systems. Interfaces, rules, data and integrations are designed together, not as isolated deliveries.
New applications, extensions and incremental modernisation of existing systems.
What you receive and how we verify it
What you receive
- React/TypeScript interfaces and components; application backends and APIs in PHP, Python or Node, as appropriate for the project.
- Data models, roles, permissions, validation and error handling.
- WordPress/Gutenberg platforms, custom functionality, multilingual content and forms connected to operational systems.
- Incremental refactoring, regression checks, build/release configuration, documentation and handover.
How we verify the result
We work through the agreed flows, including invalid inputs and denied access; we check integration and preserved behaviour. For performance, we establish a baseline and measure the change rather than promise a percentage.
Migration and rebuild work includes an inventory, backup, parity checks and rollback, under the client’s security lead; we do not provide security services.
Your rules, dedicated tools
Editors, simulators and dedicated tools
When a spreadsheet or generic UI does not express domain rules well, we build the editor, validator, simulator or utility the operator needs.
Editors, validators and simulators adapted to your workflow rules.
What you receive and how we verify it
What you receive
- A data schema and interface adapted to real tasks.
- Import/export, validation messages and previews or simulations for the agreed rules.
- Tests on representative files, distribution or deployment, and a user guide.
How we verify the result
The operator completes the agreed tasks; the consuming system accepts the export, while invalid inputs receive explanations and a path to correction.
One example domain: a game’s rules, objectives and interactions can guide the development of an editor and simulator. The modelling method also applies to other workflows.
Knowledge connected to operations
AI assistants with controlled sources and integrations
We build knowledge assistants with controlled sources, search and cited answers. We connect documentation and authorised tools in a workflow with scoped access and human verification.
Controlled sources, integrations and answer evaluation.
What you receive and how we verify it
What you receive
- Source inventory, ingestion, updates and deletion, retrieval and answer provenance.
- An interface or access channel, new authorised connectors and approvals before sensitive actions.
- An evaluation set, tests for access and unsupported answers, environment configuration, integration and hardening.
- Agreed deployment and handover; we can also evaluate an existing assistant separately.
How we verify the result
We use representative questions, conflicting information and cases without a source-supported answer. We check citations, access and content updates; thresholds are set for the intended use.
A prototype or pilot helps answer a feasibility question; it is not the limit of the collaboration. A project can continue through implementation and integration. For real data, we agree rights, access and retention; a hosted solution may use an external LLM provider assessed for the project.
Less repetitive work
Document automation and data integration
We connect applications through APIs and webhooks, forms with operational systems, and varied files with reusable reports. The goal is a verifiable data flow with visible exceptions.
Documents, reports and data flows connected through APIs.
What you receive and how we verify it
What you receive
- Ingestion, normalisation, mapping, matching rules and exception registers.
- Excel, PDF or HTML exports, and technical document generation from approved sources and rules.
- OCR for defined document families, measured against target examples, with human correction.
- Pipelines, connectors, tests, rerun procedures, integration and handover documentation.
How we verify the result
We compare outputs and totals against the approved reference, track provenance, duplicates and missing data, and verify reruns. Interpretation and approval of specialist results remain with the designated reviewer.
Financial results need specialist review; technical automation does not replace finance or accounting services.
Interactive products
Unity product development and adaptation
We differentiate and extend licensed projects and kits: gameplay, UI, content, tools and instrumentation. Working with an existing foundation can include separating configurations and adapting another product.
Gameplay, content and tools on licensed foundations.
Where it fits
When you want to extend an interactive product, adapt a licensed foundation or build tools around its content.
What you receive and how we verify it
What you receive
- Gameplay and UI implementations, level pipelines and validators.
- Core/skin configurations, content operations and updates where required.
- Analytics events, reward integration and QA scenarios.
- Build preparation, artefacts for the agreed environments, documentation and handover.
How we verify the result
We test gameplay scenarios, content, events and rewards in the approved environments. Devices and artefacts are defined for the project; app store acceptance is not guaranteed.
Our own examples: Startup Match and Shiba Sushi. The Shiba Sushi guide illustrates pieces, combinations and obstacles. Licensed foundations and third-party components are disclosed; we do not claim an engine built entirely from scratch.
A well-founded start
Feasibility analysis and software architecture
When the solution is not yet clear, we map the process, actors, data and integrations. We compare building, modernising and using an existing solution.
Feasibility, architecture options and an implementation plan.
Where it fits
When the problem involves several systems, technical options or dependencies that need to be understood before implementation.
What you receive and how we verify it
What you receive
- A map of the workflow and dependencies, constraints and open questions.
- Options and a reasoned recommendation, architecture decisions and feasibility tests where helpful.
- A delivery plan and acceptance criteria for the first useful increment.
How we verify the result
The responsible owner recognises the real process, can assess alternatives and can use the recommendation for implementation. Each unknown has a clarification action, rather than being hidden in an estimate.
Analysis can be a standalone engagement or the start of implementation. A diagnosis alone does not automatically include building the solution.
Collaboration
How we move from requirements to a working solution
We clarify the result and dependencies, build a complete increment, integrate and verify, then extend or hand over. Data, access, providers and operational responsibilities are agreed before the stages that use them. We do not require every project to begin with the same package.
Useful questions
Before we begin
A few points about collaboration, taking over an existing system and delivering a solution.
Can I start without a complete specification?
Yes. We can clarify the problem, users, data and technical dependencies, then agree a first step with a verifiable outcome. Analysis can be a separate stage or part of implementation.
Can you continue an existing application?
Yes. We begin by understanding the code, infrastructure and workflow rules. We agree the necessary access and rights, then decide together what to retain, extend and modernise incrementally.
Can you deliver AI integration, not just a prototype?
Yes. The scope can include implementation, connecting approved sources, integrations, evaluation, commissioning and handover. Data access, operational limits and acceptance criteria are agreed for the specific project.
How are the budget and timeline agreed?
After clarifying scope, dependencies and acceptance criteria. For areas that remain uncertain, we can separate an analysis stage. We do not assume the same package or schedule for every project.
What remains at the end of the collaboration?
The deliverables, checks and documentation agreed for the project. We clarify operational responsibilities, access to code and third-party components or licences that must be retained from the outset.
Which approach fits your project?
Describe the application, integration or workflow you have in mind. Ask the assistant to explain relevant capabilities, suggest possible approaches and highlight what needs clarification.
Use the conversation to prepare a brief; technical and commercial commitments are confirmed directly with us.
The next step
What do you want to build or improve?
A new application, an internal tool or systems that need to work together. We start with your context and agree a concrete next step.
For a first conversation
It helps to know what you want to achieve and what you work with now.
- The problem or workflow you want to improve.
- The systems, documents or data that already exist.
- The desired result, constraints and any deadlines.
The images on this page are provisional and can be replaced individually in the editor.