
Jacops · Construction & infrastructure
Some tenders need a new entity. We can't build a data platform from scratch for each one
A new entity already runs on a data platform of its own, built on the Jacops foundation
Project structure, model layering, SQL style, testing, CI/CD, documentation. The conventions that decide whether a dbt project stays navigable at model number 800, made once across dozens of rollouts so you don't make them again.
BEFORE WE START
What teams already running dbt, or considering it, tell us before any work starts. Each one has a way out, and the rest of this page is how we get there.
How we approach it
Folder structure organised by author or team, prefixes used inconsistently, intermediate models that quietly became gold tables. Without a layered convention and naming discipline, lineage becomes a guessing game.
How we approach it
yml files maintained in a separate folder, descriptions written once and never updated, ownership unclear, exposures undeclared. Documentation that lives away from code stops being trusted, which means it stops being read.
How we approach it
Not-null and unique tests scattered without a strategy, singular tests for things that should be generic, freshness blocks missing on the sources that matter, CI passing on broken logic. A test suite without a structure is a false sense of safety.
How we approach it
Ad-hoc {{ config() }} overrides at the top of every file, materialisations decided per model, jinja logic copy-pasted across staging and intermediate. The fix is project-level defaults in dbt_project.yml and macros for the patterns that repeat.
Six of the patterns we apply on every dbt project. Written down so you can read them before talking to us.
Staging models named stg_<source>_<entity>, one per source table, cast and rename only. Intermediate by business domain, not team. ADS as the harmonised contract for cross-source entities. Gold thin, business-ready, consumer-friendly names. Selection commands like dbt build --select intermediate.finance+ become trivial.
Materialisations, incremental strategies, quoting rules set at project and folder level. Ad-hoc {{ config() }} overrides scattered through files make behaviour impossible to reason about. Path-level settings let reviewers understand a model's behaviour from where it lives.
{{ config() }} at the top, then CTEs in a clear progression (sources, transformations, final projection), ending in a single final CTE that returns the model. Explicit columns, lowercase snake_case aliases, uppercase keywords. Diffs stay predictable, lineage audits stay tractable.
not_null and unique on every staging model and every gold fact or dimension. Relationship tests and contracts where downstream metrics depend on them. Intermediate models that stay ephemeral don't need dedicated tests; upstream staging and downstream gold cover them.
One command that materialises and tests together, so a broken model never reaches a downstream dependency. CI fails fast on test failures, freshness blocks with warn/error thresholds (warn after 18h, error after 26h) on critical sources. No green build, no deploy.
_models.yml and _sources.yml colocated with the models they describe. doc() references for canonical text, owners declared on every model, exposures wired to Power BI reports and notebooks. CI fails on undocumented models. Separate doc files always drift.
Four steps. The same every time. The decisions inside each one come from doing it dozens of times, not from reading a docs page.
One source, one mart, one stakeholder who cares. We ship one usable model end-to-end before we touch the rest of the project. Naming, layering, and tests get set with that first model.
Staging per source, intermediate by domain, ADS as the integration contract, gold thin and consumer-friendly. dbt_project.yml carries the defaults so every new model inherits the patterns automatically.
Tests saturated on sources and gold, docs co-located with models, dbt build wired into CI, freshness on the sources that matter, dbt Power User as the standard IDE setup, SQLFluff in pre-commit. The opinions are already made.
Scheduled builds, ownership on every model, exposures pointing at the dashboards that consume them. Your team adds the next mart without us, and the project stays navigable at model number 800.
For dbt you don't need a wizard. You need someone else's opinions on the decisions every project re-makes from scratch. Lift what works, fork the rest, or have us implement it for you.
dbt is the transformation layer. The platform underneath is a separate decision, and we have an opinion on both.
Databricks SQL Warehouses as the dbt adapter, Unity Catalog as the governance layer, Asset Bundles to ship the project. We bring the same opinions to the platform layer.
Native dbt jobs are now in Fabric. We use it for teams that already standardised on Fabric capacity and want SQL-first transformations on top of the lakehouse.

Jacops · Construction & infrastructure
A new entity already runs on a data platform of its own, built on the Jacops foundation
What we learned running dbt in production, written up by the people who did the work.
Strategy decides if dbt is the right pick for the transformation layer. We build it. Experts keep it running once we hand it over.
From business questions to a data, AI and software direction your organisation can follow.
Explore →Data and analytics, AI, and custom software. Built with adoption and ownership from day one.
Explore →Specialists who think like teammates. Keep your engine running and your team growing.
Explore →Half-hour call. We'll tell you if it's the right pick for your situation, and how to set up a project that stays navigable as it grows.
Book a dbt chatEager to join our team? View open positions