Engineering
Engineering for your codebase and platform.
We start with your codebase, dependencies and target environment, then make and verify the changes your product needs.
Our technology expertise.
Our core experience is in C++, C# and Unity. Our wider work covers web applications, backend services and development tools.
Core expertise
- C++
- Native software, performance-sensitive systems, application logic and service integration.
- Unity / C#
- C# application logic and Unity development, including interactive interfaces, real-time behaviour and animation integration.
Additional engineering capabilities
- Web applications
- React
- TypeScript
- JavaScript
- Backend and APIs
- Node.js
- .NET
- WebSockets
- Data
- SQL
- PostgreSQL
- MongoDB
- Redis
- Delivery and tooling
- AWS
- Docker
- Python
Changes that fit the codebase.
Before changing an existing product, we trace its dependencies and identify the shared components and behaviour that could be affected.
We discuss the trade-offs with your engineers before extending a component, adding a module or changing the surrounding structure.
- State and data flow through the affected parts of the application.
- Interfaces to shared code and the platform.
- Behaviour that must stay the same.
Your team should be able to review the change, understand it and build on it.
Measure the problem. Check the improvement.
Slow transitions, intermittent crashes and rising memory use need investigation. We first establish how to reproduce the issue and what acceptable behaviour looks like on the target device.
We profile the affected code and compare behaviour before and after a change under the same conditions. We also check for regressions elsewhere.
- Representative workloads and data.
- Response times, frame-time spikes, allocation patterns and memory growth.
- Loading, start-up and transitions between application states.
The measurements and remaining limitations help your team decide what to change or investigate next.
Adapt software to its target environment.
We first examine how your software connects to frameworks and devices, then investigate any differences in behaviour between environments.
- Framework and SDK interfaces, including version differences.
- Native modules and the assumptions they make about the environment.
- Display, input and device-specific behaviour.
- Validation on the target devices available for the engagement.
Integration decisions and known limitations should be clear to the engineers who maintain the software.
Tools for development and QA.
We look for manual steps, unclear diagnostics and inconsistent content workflows that slow your developers down.
The work may involve editor extensions, build automation or changes to shared development components.
- The task being supported and the people who perform it.
- Integration with existing tools, templates and build steps.
- Clear error messages and diagnostic information.
The tool should solve a recurring problem and remain maintainable as your workflow changes.
Client work stays confidential.
We keep client identities and project details confidential. You can assess our approach by discussing your requirements with the engineers who would do the work.
What is getting in the way of your next release?
Describe the issue, the environment and what you need to change.