Service · Software development

Custom database development.

A database is not something you fill in afterwards. It determines how fast your application keeps running as you grow, how secure the data is, and how expensive hosting becomes over five years. We design, build and maintain databases that grow with your product, from schema design for a new SaaS to performance tuning of a slow legacy system.

PostgreSQLSchema designPerformance tuningData migrationHigh availability

Database work as a specialism in its own right.

Many development teams treat the database as an implementation detail of the application. That works fine, until the first hundred thousand users arrive, the first audit comes knocking, or the first migration to the cloud lands on the table. Then it turns out the schema can't be indexed properly, read replicas can't be configured, and there is no audit log.

We treat database development as a discipline in its own right. Whether we're designing a schema for a greenfield product, tuning a slow production database, or migrating a legacy Oracle environment to PostgreSQL, we work from the requirements of the domain, not from whichever ORM the developers happen to be used to. The result is a data layer that scales predictably, can be maintained by your team, and won't need redesigning in a year's time.

We work both within our broader cloud-native platform development and on standalone database projects. Many of our clients come to us with a specific problem, such as a query that is too slow, a migration that feels risky, or an audit requirement that has suddenly appeared, and don't want a completely new platform straight away.

Three types of database project.

What we do depends on where your organisation stands. A new application needs different attention from a ten-year-old system that suddenly stops scaling.

Greenfield: schema design for a new application

Schema design from scratch

For new SaaS products, e-commerce platforms or custom applications, we help design the data model. Together we determine which entities, relationships and indexes are needed, which columns can be polymorphic, and which normalisation choices will keep the system workable five years from now. We build in multi-tenant design (row-level security or schema-per-tenant), audit logging and an encryption strategy from the very start.

PostgreSQLMulti-tenantAudit logMigrations
Performance tuning and optimisation

Making a slow database faster

The classic call: "our app has become slow over the past year." We analyse slow query logs, EXPLAIN plans and index statistics. We tackle n+1 problems, rewrite poorly written joins, add missing indexes and, where needed, revise the connection pool configuration. We often achieve order-of-magnitude improvements without the schema needing to change fundamentally.

EXPLAIN ANALYZEpg_stat_statementsIndex strategyQuery rewrite
Migration and architecture project

Database migration and redesign

Oracle to PostgreSQL, on-premise SQL Server to Aurora, splitting up a monolithic database, or moving from SQL to a hybrid model with document or time-series storage. We map out the data model, design the target architecture, and carry out the migration in phases using dual-write or CDC so production keeps running. We often work together with our platform migration teams.

Oracle → PostgreSQLSQL Server → AuroraCDC / DebeziumZero downtime

What you get at the end.

No loose dump files or a Confluence page. A working production database, documented in a way your own team can carry on with.

  • The database environment itselfProduction and staging, with replication, backups and monitoring in place. Runs in your cloud (GCP, AWS, Azure) or with us.
  • Schema and migrations as codeVersioned migrations via Flyway, Liquibase, Atlas or Prisma Migrate. Every change is traceable, reversible and reproducible.
  • Documentation and ERDsSchema diagrams (dbdiagram, DBeaver), column glossary and architecture overview. Written to be handed over, not to serve as a paper trail.
  • Backup and recovery procedurePoint-in-time recovery, a tested restore script and clearly documented RPO/RTO figures. We carry out at least one real restore before handover.
  • Monitoring and alertingpg_stat dashboards, Prometheus exporters and slow-query alerts. Your team sees spikes coming, rather than finding out when users complain.
  • Managed service contract (optional)Patching, capacity planning and ongoing performance reviews. Fixed monthly price, with four response-time tiers.

When database work deserves its own project.

Not every database issue is a service in its own right. But we keep seeing these patterns, and in these cases dedicated database work makes the difference between patching over problems and solving the underlying one.

Performance

Queries keep getting slower

The application used to be fast, but with every release another quarter of an hour is added to response times. The slow-query log keeps growing, users complain, and the developers are afraid to touch the schema.

Scale

One database is hitting its limits

You're running up against what a single instance can handle. Sharding, partitioning, read replicas or a split between OLTP and OLAP is becoming unavoidable.

Migration

Legacy has to go

Oracle licences are expensive, SQL Server needs to move to the cloud, or an outdated MySQL 5.7 needs replacing. You don't want a big-bang migration, but a phased move with no downtime.

Compliance

Audit requirements are changing

GDPR deletion, the right to be forgotten, retention policies, and audit logging of who changed what. Handled too crudely in the application layer, this belongs at database level.

Multi-tenant

Customer isolation is becoming risky

Your multi-tenant platform is growing and the current approach (a single tenant_id column with queries that filter on it) is becoming fragile. Row-level security or schema-per-tenant becomes necessary.

AI / vector search

Adding RAG or semantic search

You want to add an AI feature using retrieval-augmented generation, semantic search or similarity matching. That calls for pgvector, a dedicated vector database, or a hybrid approach where both run side by side.

How a database project works with us.

1

Inventory and analysis

We map out the current model: schema, volumes, slow queries, monitoring data and usage patterns. For a greenfield project we do the same, but based on the use cases and read/write patterns you anticipate.

2

Architecture choices

Which database suits this domain? PostgreSQL by default, but sometimes ClickHouse for analytical queries, TimescaleDB for time series, or MongoDB for heavily nested documents. We justify every choice and compare the alternatives side by side.

3

Schema and migrations

The data model is delivered as an ERD, as a migration script and as a testable schema definition. Your team can follow along, suggest indexes, and see how queries will perform under load through benchmarks on realistic volumes.

4

Implementation and migration

For new databases: build, integration with the application, and load testing. For migrations: dual-write or CDC so production keeps running, followed by a controlled cut-over. We always do a dry run before going to production.

5

Monitoring, handover and management

Dashboards, alerts and runbooks for incident response. Your team gets training on the chosen tools, and we either hand management back completely or keep it under an ongoing contract with us.

What we work with.

We're not tied to a single vendor or stack. We advise based on what best fits your domain, team and existing systems.

Relational: our default for custom software

SQL databases

PostgreSQL is our first choice for custom applications: a rich feature set, strong standards, no licence lock-in and excellent cloud support. We also work with MySQL and MariaDB (mainly for existing LAMP stacks), Aurora within AWS, Oracle in legacy contexts, and SQL Server in Microsoft environments.

PostgreSQLMySQLMariaDBAuroraOracleSQL Server
NoSQL and specialised stores

Document, key-value, time-series, graph

For heavily nested documents, we use MongoDB or CouchDB. Redis, ValKey and DynamoDB handle caching and session storage. TimescaleDB or InfluxDB suit sensor and metrics data. Neo4j or ArangoDB work well for relationship-heavy problems such as fraud detection or recommendations. For search functionality, we choose Elasticsearch, OpenSearch or Meilisearch, depending on scale and budget.

MongoDBRedisDynamoDBTimescaleDBNeo4jElasticsearch
Analytical, vector and wide-column

OLAP, AI and large volumes

For analytical workloads and data warehouses, we use ClickHouse, Apache Druid, BigQuery, Snowflake or Databricks. See also our work on real-time analytics platforms. For AI/RAG implementations, we use pgvector within PostgreSQL or a dedicated vector store such as Pinecone or Weaviate. For extremely high write volumes, we use Cassandra or ScyllaDB.

ClickHouseBigQuerySnowflakepgvectorPineconeCassandra

Tooling we use.

Database work is a craft with its own tools. Below are the tools that come up in almost all of our projects. The list is not exhaustive, but it is representative.

  • ORMs and query buildersPrisma and TypeORM for TypeScript stacks, SQLAlchemy for Python work, Hibernate or jOOQ in Java environments. We write SQL where the ORM can't cope.
  • Schema migrationsFlyway and Liquibase in enterprise settings, Atlas for declarative schemas, Prisma Migrate or TypeORM migrations for JS/TS work. Always version-controlled, and reversible wherever possible.
  • Performance analysispg_stat_statements, pgBadger, EXPLAIN ANALYZE, auto_explain. For MySQL/MariaDB, the Performance Schema and sys schema. For SQL Server, Query Store and DMVs.
  • Schema design and visualisationdbdiagram.io for quick ERDs, DBeaver and DataGrip for day-to-day work, SchemaSpy for automatically generated documentation.
  • Backup and recoverypgBackRest and Barman for PostgreSQL, native point-in-time recovery in Aurora and Cloud SQL, and verified restore scripts in our runbooks.
  • MonitoringPrometheus exporters, Grafana dashboards, DataDog Database Monitoring, and CloudWatch where it fits. Slow-query alerts and index-bloat checks as standard.
  • CDC and data pipelinesDebezium for change data capture, Kafka or Pulsar for transport, and dbt for transformations into analytical environments.

Frequently asked questions.

What clients usually want to know before we start on database work.

PostgreSQL or MongoDB: which should I choose?
By default, we choose PostgreSQL for custom applications. It is stronger for relational work, transactions, complex queries and consistent data. MongoDB gains the advantage if you have heavily nested, loosely structured documents (think content management, IoT payloads, event data) or a team that already works deep in the JavaScript stack. A hybrid approach is often sensible: PostgreSQL for the transactional core, MongoDB or another document store for derived, rarely queried data. We help you make that choice before you commit to a single model.
When is performance tuning enough, and when do you need a redesign?
The vast majority of performance problems can be solved without changing the schema: adding or removing indexes, rewriting queries, tackling N+1 problems, adjusting the connection pool, updating statistics. Redesign only comes into play when the foundations of the schema no longer match how the system is used — think of a heavily normalised schema that constantly has to do forty joins, or a polymorphic model that makes indexing impossible. We always start with an analysis phase so it is clear which route delivers the biggest gain.
Can you carry out a database migration with zero downtime?
Yes, in almost all cases. We use a combination of dual-write (the application temporarily writes to both the old and the new database), change data capture (Debezium reads the transaction log of the source system and replicates it to the target system) and gradual read switching. A short cut-over of a few seconds is sometimes needed, but we can almost always avoid full maintenance windows. Our platform migration approach describes the complete way of working in more detail.
How do you handle GDPR deletion and data retention at database level?
We prefer to build the right to erasure and retention policies into the database layer rather than the application. That means a deletion pipeline that traces all related records via foreign keys, optional soft delete with a TTL for compliance windows, and audit log entries that record the deletion itself. For analytical copies we use hash pseudonymisation or full anonymisation at the ETL step. That way, a GDPR request is a repeatable process, not an ad-hoc emergency job.
Do you also work with our existing developers, or do you do everything yourselves?
Both. Many clients have a good application team but no dedicated database engineer; in that case we act as the specialist between the team and the data layer. Other clients want the whole process — schema, application integration, maintenance — handled by us. We are happy to work with your own developers, hand over knowledge in every sprint, and make sure your team can continue on its own after delivery.
What about security: encryption, access control and auditing?
Encryption at rest (transparent data encryption or the cloud-managed equivalent), TLS for all connections, role-based access control following the principle of least privilege, and separate service accounts per application component. For audit purposes we log who changed which row, with before/after values, in a separate audit table or via database triggers. For sensitive columns we use column-level encryption or pseudonymisation. We also support penetration tests and compliance audits if the project falls within a NEN 7510 or ISO 27001 environment.
What does a database project cost?
Too variable to give a figure without knowing your situation. A performance quick scan on a single production database is a very different project from a complete migration from Oracle to PostgreSQL with dual-write. We work with fixed sprint budgets — you know in advance what a sprint costs and what will be finished at the end. In the introductory call we give a first indication of scope and number of sprints; for more complex projects we start with a short analysis phase before asking for a larger commitment.

Talk to us about your database challenge.

A no-obligation introductory call of half an hour. Tell us where your database is getting stuck, which product you want to build, or which migration is on the table. We listen, ask questions, and give you direction you can actually use — even if it turns out we are not the logical party.

Edit content