IT company · Software engineering
Software,
built to last.
DIT DAT ALLES designs, builds and maintains custom software, web and mobile applications, and the cloud infrastructure underneath them.
01 / What we do
We turn business needs into working software — and then keep it working. Strategy, design, engineering, testing and operations under one roof.
Most software problems are not purely technical. They sit between people, processes and existing systems. Our work starts there: understanding how an organisation actually operates before writing code.
From that understanding we build focused tools, product-grade applications and integrations, delivered in small increments so progress is visible and direction can change as you learn.
Frontend
Accessible, fast interfaces for web and mobile, built on component systems that scale with the product.
Backend & APIs
Service layers, data models and APIs designed around clear contracts and predictable behaviour.
Data
Relational and document storage, migrations, reporting pipelines and data integrity rules.
Cloud
Containerised workloads, infrastructure as code, environments that can be recreated on demand.
Automation
CI/CD pipelines, automated tests and release workflows that reduce manual, error-prone steps.
Integration
Connecting new software to existing systems, third-party platforms and internal tools.
03 / Services
Eight disciplines, one team.
Each service can be engaged on its own or combined into a complete delivery. Full descriptions are on the Services page at /services.
- 01Custom software development
- 02Web application development
- 03Mobile application development
- 04UI/UX design
- 05Cloud & DevOps engineering
- 06Software testing & QA
- 07System integration
- 08Maintenance & technical support
04 / Problems we help solve
Where software makes the difference.
Processes run on spreadsheets and email
We turn recurring manual work into structured software with clear roles, validation and history.
An existing system is hard to change
We map what exists, stabilise it with tests, and modernise it in steps instead of risky rewrites.
Tools don't talk to each other
We design integrations so data moves between systems reliably and is entered only once.
Releases are slow and stressful
We introduce automated pipelines and environments so changes ship in small, reviewable increments.
An idea needs a first working product
We help define the smallest useful scope and build a foundation that can grow afterwards.
- 1
Discover
Understand goals, users, constraints and existing systems. Agree on what success looks like.
- 2
Define
Shape scope, priorities and architecture. Produce a plan the whole team can read.
- 3
Design
Wireframes, interface design and technical design reviewed before heavy implementation.
- 4
Build
Short iterations with working software at the end of each, reviewed in code and in demos.
- 5
Verify
Automated and manual testing against agreed acceptance criteria.
- 6
Release
Controlled deployment with monitoring, rollback paths and documentation.
- 7
Evolve
Maintenance, improvements and support based on real usage.
06 / Architecture & engineering principles
Simple before clever
The most maintainable solution is usually the one a new engineer can understand in an afternoon.
Explicit boundaries
Modules communicate through defined interfaces so parts can change without breaking others.
Observable by default
Logging, metrics and error reporting are part of the build, not an afterthought.
Reversible decisions
We prefer choices that can be undone, and document the ones that cannot.
07 / Cloud & infrastructure
Infrastructure you can rebuild from a file.
Environments defined as code, so staging and production stay consistent and can be recreated when needed.
Container-based deployments, automated pipelines, backups and monitoring configured from the first release.
Cost-aware sizing: resources matched to real load, reviewed as usage changes.
Documentation of how everything fits together, so your team is never locked out of its own systems.
08 / Quality assurance
Tested at every layer.
| Layer | What it checks | When |
|---|---|---|
| Unit | Individual functions and business rules | Every commit |
| Integration | Services, databases and external APIs together | Every merge |
| End-to-end | Critical user journeys in a real browser or device | Before release |
| Exploratory | Edge cases and usability, by a person | Each iteration |
| Accessibility | Keyboard use, contrast, screen-reader semantics | Design & release |
09 / Security-aware development
Security is a habit, not a phase.
Least privilege
Users, services and keys receive only the access they need.
Secrets handling
Credentials kept out of source code and rotated when people or systems change.
Dependency hygiene
Third-party packages monitored and updated on a regular schedule.
Input validation
All external input is validated at the boundary before it touches business logic.
10 / Collaboration & communication
No black boxes.
You see the work as it happens: regular demos of working software, a shared backlog, and written decisions you can revisit later.
- Cadence
- Agreed check-ins and iteration reviews
- Visibility
- Shared task board and progress notes
- Decisions
- Recorded with context and trade-offs
- Handover
- Documentation and knowledge transfer
11 / Questions
Frequently asked.
- What kind of projects does DIT DAT ALLES take on?
- Custom business software, web applications, mobile apps, cloud and DevOps work, integrations between systems, and ongoing maintenance of existing software.
- Can you work on an existing codebase?
- Yes. Work on existing systems usually starts with a technical review to understand structure, risks and test coverage before changes are planned.
- How is a project scoped?
- Through an initial discussion of goals, users and constraints, followed by a written proposal describing scope, approach and deliverables.
- Do you also design the interface?
- Yes. UI/UX design can be part of a project or offered on its own, from user flows and wireframes to a complete visual design system.
- Who owns the source code?
- Ownership and licensing terms are agreed in writing for each engagement before work begins.
- Is support available after launch?
- Maintenance and technical support can be arranged as a continuation of a project or for software built by others.
- How do we start?
- Send an email to [email protected] describing what you want to build or improve. The Contacts page lists what is helpful to include.
12 / Contact
Let's talk about what you're building.