Data Supply Chain Architect / Analytics Engineer · Product.ai
Owns the structured data layer that the company’s content pipelines, story generation, and verification engine all drink from — the engineer who decides what data hundreds of thousands of pages are built on every night.
İstanbul-trained analytics engineer turned data-substrate architect. If the data is wrong, thousands of bad pages get generated; when it’s right, every team downstream ships without re-asking the same question. Turns unstructured signals into reconciled, machine-readable pipelines — and ships the spec, the code, and the honest label in the same session.
Data Supply Chain Architect / Analytics Engineer — the engineer who turns unstructured merchant signals into the reconciled, machine-readable substrate every other team builds on.
Federated reads across the commerce data warehouse, web-analytics telemetry, and search-console automation. The signals come from everywhere; she normalizes them into one place.
A transformation layer built on modern data-modeling tooling — canonical tables, density scoring, self-serve columns reviewable without writing SQL.
Cross-source bridges between systems that never agreed — manual trackers, warehouse row counts, adapter folders. Three sources of truth, one map.
Fetchability canaries at startup, stratified sampling, history logs, multi-channel failure surfaces. Detection horizons compressed from weeks to seconds.
Four load-bearing specs in 30 days. Specs ship with their self-critique cycle in the body, not the appendix — so future readers see why the thresholds are where they are.
End-to-end testing behind authentication against live production — a reusable pattern for verifying any internal dashboard before it ships.
The work isn’t writing SQL — it’s removing the need for anyone to write SQL ad-hoc again. The North Star is the move from manual queries to autonomous data infrastructure: pipelines that refresh themselves so the teams downstream never have to re-ask the same question.
It carries a discipline most data work skips: if a version-one has a scope limit, label it — visibly, inside the interface, not buried in a footnote. Trust is earned by saying plainly what doesn’t work yet, not by claiming everything is supported.
And it treats AI the way it treats data: as a subsystem to govern, not an oracle to defer to. Current models act exactly like rushed humans — they skim, guess, and take shortcuts unless told otherwise. The same rigor that goes into a data model goes into every prompt.
Turn unstructured signals into the substrate other people can build on without re-asking the same question. Cansu, on the through-line of the work
The work isn’t writing SQL — it’s removing the need for anyone to write SQL ad-hoc again. Manual queries become self-refreshing pipelines.
“By end of quarter, the generators run on self-refreshing pipelines with zero ad-hoc SQL from me.”
One canonical table standard, one runtime lookup pattern. Every reader uses one source; every writer goes through one path. No second source of truth.
“One canonical source per first-class entity — remember it in every session.”
Scope limits ship inside the interface, not in a footnote. A methodology change gets pre-communicated to the people relying on it before they rely on it.
“Don’t frame it as everything is supported. Frame it as what actually is.”
Aggregate metrics quietly drop what was attempted-and-failed. A fetchability canary caught what weeks of dashboard reads missed — then got written into the framework so every future launch inherits the rule.
“What is the gate actually trying to catch, and what filters does that imply?”
Every framework spec carries its self-critique cycle inside the document. Future readers see why thresholds are where they are, not just what they are.
“Be rigorous. Critique your output and make it better. This part is incredibly crucial.”
Separate prompt-design from execution. Force self-verification through explicit checkpoints. Demand extreme explicitness — the same rigor she brings to data models.
“Current models act exactly like rushed humans: they skim, guess, and take shortcuts unless explicitly told otherwise.”
Anti-goals are part of the role description, not a footnote. Cansu’s scope is the data layer — supplied to every other domain, executed in none of them.
Every signal, normalized into one place.
Federated warehouse reads, web-analytics streams, and search-console automation, joined into a single reconciled layer.
One canonical source per thing.
A modern transformation layer, a canonical table standard, and cross-source bridges that reconcile systems which never agreed.
The specs the queries get written against.
Content-density scoring, rollout-observation and analysis frameworks, reporting-QA — four load-bearing specs, each with its self-critique cycle in the body.
Failure surfaces, not silent gaps.
Fetchability canaries, stratified samples, history logs, multi-channel failure surfaces, and behind-authentication production testing.
Builds the data layer; humans build the surfaces.
She supplies the modeled, reconciled data — the visual surfaces on top of it are owned elsewhere.
Supplies the substrate; doesn’t run the domain.
The verification engine, the operating model, and editorial content all drink from her data layer — she builds the layer, not the domains on top of it.
Separate prompt-design from execution. Force self-verification via explicit checkpoints. Demand extreme explicitness. “Read 100% of this file line by line” — not “Review this file.”
Logging gaps, schema fixes, upstream design flaws — often easier to solve with basic engineering conversations than with intricate workflows. “Just because you have a hammer, doesn’t mean everything is a nail.”
Most analytics engineers ship queries. Cansu ships the specs the queries get written against — four load-bearing frameworks in 30 days, each consumed by another team’s downstream work.
Manual trackers, adapter folders, warehouse row counts — three sources of truth that never agreed, until she built the framework and the lookup that bridge them. One canonical source, made physical.
The gotchas memorialized, the bridge-keys saved, the chart annotations added. Cleanup isn’t a side activity — it’s woven into every shipping session.
Scope limits live inside the interface, not in a footnote. A version-one ships with its limits visible. Trust earned by saying what doesn’t work.
Multi-agent orchestration at production scale — AI treated as a subsystem to govern, not an oracle to defer to. The published-thinking principle made code.
Six years of engineering school, seven years in analytics, and dashboard fixes that collapse two-week timelines into two days. The depth and the velocity arrive together.
Turn unstructured signals into the substrate other people can build on without re-asking the same question — from the user-insights desk through the framework-author tier, shipping the spec, the code, and the honest label in the same session.
Product.ai builds with operators like Cansu — engineers who own a layer end-to-end and ship it with the honest label attached. See open roles →