Supervised learning assumes someone hands you the truth. In fraud, the truth arrives 30 to 90 days late, labeled by processes with their own agendas, for only the transactions you approved — and silence means nothing, because unreported fraud and un-disputed legitimate purchases are indistinguishable until they aren't. Label engineering is the least glamorous layer of a fraud system and the one that decides whether everything upstream learns reality or a convenient fiction.
Labels are an engineered pipeline: maturity horizons (recent silence is not legitimacy), labels as versioned state trajectories, early proxies weighted then reconciled; noise handled by provenance; and censoring confronted with bought data — bounded exploration of would-be declines booked as data acquisition cost.
Every AI financial system is built on data, and in finance the data is uniquely treacherous: expensive, fragmented, revised after the fact, survivor-biased, and riddled with subtle ways to accidentally see the future. Getting the data foundation right matters more than any model — a brilliant model on leaky or biased data is a confident path to losing money. This post is about the financial data landscape and the traps that make it the hardest, most decisive part of the work.
Every financial AI system lives or dies on its data, and financial data is uniquely treacherous: expensive, fragmented, revised, survivor-biased, and riddled with ways to accidentally see the future. The landscape (market, document, proprietary data) and the traps — lookahead, survivorship, point-in-time correctness — that make it the most decisive part. (Educational, not financial advice.)
In a large organization the hardest data problem isn't storage or speed — it's that nobody agrees what "customer," "revenue," or "active user" actually means, and every team computes them differently. A semantic layer is the ontology applied to the enterprise: a shared, governed definition of the business's concepts and relationships that sits above the scattered data and gives everyone — dashboards, analysts, and now AI agents — one consistent meaning to build on. This is where ontologies deliver their most concrete business value.
The enterprise ontology made operational: a governed layer that defines the business's entities, relationships, and metrics once, so dashboards, analysts, and AI agents all inherit the same definitions. Why 'revenue' means three things, and why AI made the semantic layer urgent — an agent is only as correct as its grasp of your terms.
The hardest part of a knowledge graph isn't querying it or designing the ontology — it's building it from messy, real-world data. Most of your knowledge lives in databases that don't connect, documents that don't parse, and records that refer to the same thing by different names. Construction is the engineering of turning that mess into a clean, connected graph, and its central, unglamorous challenge is entity resolution: deciding when two records are actually the same thing. This post is about the work that makes or breaks a knowledge graph.
The hard part isn't the ontology or the queries — it's construction. The pipeline from heterogeneous sources, and its make-or-break challenge: entity resolution (deciding when two records are the same thing). Under-merging fragments; over-merging asserts false connections; connectivity amplifies every error.
An ontology is the blueprint; a knowledge graph is the building. A knowledge graph is a network of real-world entities and the relationships between them, structured against an ontology so that both humans and machines can navigate it, query it, and reason over it. They power web search, recommendations, fraud detection, and increasingly the grounding of LLMs — and understanding what makes a graph a "knowledge" graph is understanding why this shape of data keeps winning for connected problems.
A knowledge graph is the ontology populated — entities as nodes, typed relationships as edges, integrated from many sources. RDF vs property graphs, and why graphs win for connected problems: relationships are first-class (traversal, not join cascades), the schema flexes, and meaning lives in structure.
Every compliance control eventually produces something you must tell a regulator: a suspicious activity report, a transaction report, a periodic filing. Regulatory reporting is where your internal compliance data becomes an external, deadline-bound, precisely-formatted obligation — and it's an unglamorous data-engineering problem where accuracy and timeliness are legal requirements, not quality goals.
Every compliance control eventually produces something you must tell a regulator: a suspicious activity report, a transaction report, a periodic filing. Reporting is where internal compliance data becomes an external, deadline-bound obligation where accuracy and timeliness are legal requirements.
You can pick the perfect technique, tune every hyperparameter, and rent the best GPU — and still get a worse model than you started with, because your dataset was mediocre. Fine-tuning quality is decided overwhelmingly by data quality, and a few hundred excellent examples beat tens of thousands of sloppy ones. This is the post that actually determines whether your fine-tune works.
You can pick the perfect technique and rent the best GPU, and still get a worse model, because your dataset was mediocre. Fine-tuning quality is decided overwhelmingly by data quality, and a few hundred excellent examples beat tens of thousands of sloppy ones.
Model quality is bounded by data quality, and the defects you tolerate here — poor lineage, silent drift, unmanaged PII, careless retrieval — resurface downstream as hallucinations, bias, privacy incidents, and un-auditable decisions.
Model quality is bounded by data quality; poor lineage, silent drift, unmanaged PII, and careless retrieval resurface as hallucinations and privacy incidents. Phase 2: the governed data foundation.
Knowing the concepts and the engines is one thing; building a stream-processing pipeline that's correct, reliable, and operable in production is another. This closing post assembles the series into practical judgment: how to design a streaming pipeline, the operational realities that trip teams up, and when to reach for streaming at all. It turns the theory of data-in-motion into something you can actually run.
Designing a streaming pipeline (source, processing, sink) and the operational realities — it runs forever, state is the crux, backpressure and lag, reprocessing, hard testing — plus the honest judgment: use streaming only when latency genuinely justifies its complexity over simpler batch.
The concepts of stream processing — events, time, windows, state, fault tolerance — are realized by a handful of systems, and choosing among them is one of the main practical decisions in building a streaming pipeline. This post maps the landscape: the engines, the models they embody, and how to think about which fits a problem. It's the bridge from understanding stream processing to actually running it.
The engines that implement stream processing: Flink (the heavyweight true stream processor), Spark Structured Streaming (micro-batch), Kafka Streams (library on Kafka), cloud-managed services, and the unifying Beam/Dataflow model. How to choose by state/correctness, ecosystem, ops capacity, and latency — plus the rise of streaming SQL.
A stream-processing job runs forever, which means it will experience failures — nodes crash, networks partition, processes restart. The question isn't whether failure happens but what happens to your results when it does: do you lose events, double-count them, or get exactly the right answer anyway? Fault tolerance, and the famous "exactly-once" guarantee, are what separate a toy stream processor from one you can trust with money. This post is about surviving failure correctly.
A forever-running job will fail, so the delivery guarantee matters: at-most-once (may lose), at-least-once (may duplicate), or exactly-once (correct as if neither). How checkpointing and replayable sources achieve exactly-once semantics, and choosing the guarantee by need — with idempotency as the pragmatic route.
Simple stream operations — filter this event, transform that one — need no memory. But the interesting computations — counts, aggregations, joins, windows, pattern detection — require remembering things across events, and that memory is state. Managing state correctly over an unbounded stream, at scale, with fault tolerance, is the hardest engineering problem in stream processing. This post is about state: why it's needed, what makes it hard, and how stream processors manage it.
Interesting stream computations — counts, aggregations, joins, windows, patterns — need to remember across events, and that memory is state. Why state is hard on an unbounded stream (bounding, speed, partitioning, surviving failure), and how engines provide managed keyed state.
You can't average an infinite stream, or count "all" the events in something that never ends. Windowing is how stream processing carves the unbounded flow into finite, computable chunks — the last minute, each hour, each user session — so that aggregations become meaningful. It's the single most-used concept in practical stream processing, and understanding the window types is understanding how most real streaming logic is expressed.
You can't aggregate an infinite stream, so windowing carves it into finite chunks. Tumbling, sliding, and session windows; triggers that control when a window emits; and how windowing sits on event time and watermarks to produce correct, finite results — the dominant pattern in real stream processing.
Post 2 ended on a hard problem: you need event-time results, but events arrive late and out of order, so you never know when you've seen everything for a given time. Watermarks are stream processing's elegant answer — a running estimate of how far event time has progressed, letting you decide when it's safe to produce a result. They're the mechanism that makes correct event-time computation possible over a messy, unbounded stream.
Watermarks are stream processing's answer to late, out-of-order events: a running estimate of how far event time has progressed, letting you decide when it's safe to emit a result. How they make the completeness-vs-latency tradeoff explicit and tunable, and how to handle late events.
Stream processing has a small, elegant core model: everything is an event, events form streams, and time is a first-class concern. Getting these three ideas precise — especially the subtle and crucial distinction between when an event happened and when you process it — is what makes the rest of stream processing (windowing, state, correctness) comprehensible. This post builds the core vocabulary that everything else depends on.
The core model: events, streams, and time as first-class. The crucial, most-misunderstood distinction between event time (when it happened) and processing time (when you handle it), why correct answers depend on event time, and why that makes time the central problem of streaming.
Most software processes data at rest: you store it, then query it. Stream processing flips that — it computes on data in motion, as each event arrives, continuously and forever. This shift from "store then process" to "process as it flows" underpins fraud detection, real-time analytics, monitoring, and the event-driven systems that react to the world as it happens. This series builds stream processing from first principles, starting with why computing on data in motion is a fundamentally different model.
Most software processes data at rest; stream processing computes on data in motion, as each event arrives, continuously and forever. Batch vs stream, why unboundedness makes streaming hard, and when latency justifies its complexity over simpler batch.
All the components — pipelines, warehouses, models, batch and streaming, the modern stack, quality and governance — come together in a single job: keep reliable, usable data flowing to the people and systems that need it. Doing that in the real world is less about any one technology than about a mindset: treating data pipelines as production software that must be reliable, tested, observed, and maintained. This closing post is about data engineering as it's actually practiced, and where it's heading as AI makes good data more valuable than ever.
All the components come together in one job: keep reliable, usable data flowing to the people and systems that need it. Doing that in the real world is less about any one technology than about a mindset — treating data pipelines as production software that must be reliable, tested, observed, and maintained. Plus where the field is heading as AI makes good data more valuable than ever.
The most dangerous failure in data engineering is the one that doesn't announce itself. A crashed pipeline gets noticed; silently wrong data flows straight into dashboards and models, where people trust it and make decisions on it — wrong decisions, confidently made. Data quality and governance are the disciplines that guard against this: ensuring data is correct, trustworthy, and well-managed. They're the least glamorous and most important part of production data engineering, because without them, all the pipelines and warehouses just deliver garbage efficiently.
The most dangerous failure in data engineering is the one that doesn't announce itself. A crashed pipeline gets noticed; silently wrong data flows straight into dashboards and models, where people trust it and make wrong decisions confidently. Data quality and governance are the disciplines that guard against this.
A decade ago, building a data platform meant heavy, monolithic, on-premises systems and long projects. Today it's assembled from specialized cloud tools that snap together around a central cloud data warehouse — ingest here, transform there, visualize over there — each best-in-class at one job. This "modern data stack" is less a specific set of products than an architecture and a philosophy, and understanding its shape (and what drove it) is understanding how data platforms are actually built now.
A decade ago, a data platform meant heavy, monolithic, on-premises systems. Today it's assembled from specialized cloud tools that snap together around a central cloud data warehouse — each best-in-class at one job. This 'modern data stack' is an architecture and a philosophy, and understanding its shape is understanding how data platforms are built now.
How fresh does the data need to be? That one question splits data engineering into two paradigms. Batch processing handles data in large chunks on a schedule — simpler, cheaper, and fine when yesterday's data is good enough. Stream processing handles data continuously as it arrives — more complex and costly, but necessary when you need to know now. Choosing between them (and knowing when each fits) is one of the most consequential architectural decisions in a data platform, and it's driven by real requirements, not by which sounds more impressive.
How fresh does the data need to be? That one question splits data engineering into two paradigms. Batch processing handles data in chunks on a schedule — simpler and cheaper. Stream processing handles data continuously as it arrives — more complex, but necessary when you need to know now.
The same data can be organized in ways that make analytical queries fast, intuitive, and cheap — or slow, confusing, and expensive. Data modeling is the craft of that organization, and it's where a counterintuitive truth lives: the careful normalization that's correct for application databases is often exactly wrong for analytics. Analytical data wants to be shaped differently, around how questions are asked rather than how data is written, and understanding dimensional modeling is understanding how to make a warehouse actually usable.
The same data, organized differently, makes analytical queries fast and intuitive — or slow and confusing. Data modeling is the craft of that organization, and it holds a counterintuitive truth: the normalization that's correct for application databases is often exactly wrong for analytics.
"Just put it in a database" stops working the moment you're dealing with analytics at scale — because the database that runs your application is optimized for exactly the wrong thing. Analytical data needs different storage: systems built to scan and aggregate huge volumes, not to serve fast individual transactions. The landscape of analytical storage — data warehouses, data lakes, and the newer lakehouses — is where data engineering decisions about where data lives get made, and understanding the differences (starting with OLTP vs OLAP) is essential.
'Just put it in a database' stops working the moment you're doing analytics at scale — the database that runs your app is optimized for exactly the wrong thing. Analytical data needs different storage: warehouses, lakes, and lakehouses. Understanding the differences (starting with OLTP vs OLAP) is essential.
The core artifact of data engineering is the pipeline: an automated flow that pulls data from somewhere, reshapes it, and lands it somewhere useful. And the single most consequential shift in modern data engineering is captured in three reordered letters — ETL became ELT — a change driven by cheap, powerful cloud data warehouses that flipped when and where transformation happens. Understanding pipelines, and the ETL-to-ELT shift, is understanding how data actually moves and gets made usable.
The core artifact of data engineering is the pipeline: an automated flow that pulls data from somewhere, reshapes it, and lands it somewhere useful. And the single most consequential modern shift is captured in three reordered letters — ETL became ELT — driven by cheap, powerful cloud data warehouses that flipped when and where transformation happens.
Every dashboard, every analytics query, every machine-learning model, and every "data-driven decision" rests on an invisible foundation: someone built the pipelines that collect, move, clean, and organize the data so it's actually usable. That someone is a data engineer, and their work is the unglamorous, essential plumbing beneath everything data. When it works, no one notices; when it breaks, every downstream report and model breaks with it. Understanding data engineering is understanding how raw data becomes something a business can actually use.
Every dashboard, analytics query, and ML model rests on an invisible foundation: someone built the pipelines that collect, move, clean, and organize the data. That someone is a data engineer, and their work is the essential plumbing beneath everything data. When it works, no one notices; when it breaks, every downstream report and model breaks with it.
BigQuery has had a built-in knowledge graph since 2024. For entity resolution across millions of rows — the "is this John Smith the same as that John Smith" problem — it's the cheapest tool I've found.