An interactive report that executives will ignore until they ask for the same data… in an Excel sheet.

Technologically frozen in 1995. Still thinks "the cloud" is for rain and refuses to click anything newer than Solitaire.

Corporate for "I forgot what this is about but I need to make noise before someone notices".

Removing errors, duplicates, and someone else’s bad decisions.

The algorithm that helps machine learning models learn—think of it as slowly rolling downhill to the right answer.

The thing everyone builds but nobody documents.

A fragile house of cards filled with hidden errors, broken formulas, and misplaced decimal points.

Shoving a half-baked feature into the project at the last minute.

When two teams argue over whose data is right until they both give up.

Granting permissions based on job roles, not personal favorites.

“This dashboard is broken, but let’s not discuss it in front of leadership.”

Cutting back on data storage costs until everything runs painfully slow.

Predicting trends over time—useful for stocks, weather, and figuring out when your Wi-Fi will crash again.

It’s not just a conference—it’s a group hug wrapped in YAML. No fluff, no gatekeeping—just real talk from data practitioners sharing their learnings and strategies.

Making teams promise they won’t break each other’s data pipelines.

The dream every company sells but never actually delivers.

“This report is valid until next quarter, when everything changes.”

The universal answer to every data question, forever and always.

The badge that says “We take security seriously” (but still have breaches).

Google's open-source machine learning library—great for deep learning, if you don’t mind the steep learning curve.

Modeled after the human brain, but way less reliable at common sense. Great at deepfakes, though.

Blueprints for security that companies try to follow.

Because bad data leads to bad decisions and lots of excuses.

A structured way to describe data relationships (or overcomplicate things).

Teaching models with labeled data—kind of like school, but for algorithms.

Trust no one, verify everything. Paranoia as a security strategy.

Because mistakes were made.

Treats your dashboards like a digital coloring book.

Because someone needs to process transactions in real-time.

The buzzword architects love, but engineers fear.

Renting someone else’s servers but paying more.

A last-minute meeting because someone didn’t read the dashboard.

Protecting user info while secretly monetizing it.

Wants to monitor every client blink without a clue what to do with it.

Turns their poor planning into your emergency with Slack messages that induce cardiac events.

The stuff hackers (and marketers) dream about stealing.

Data that refuses to fit into neat tables—think text, images, and the chaos of the internet.

Keeping multiple copies of your data in sync.

The law that keeps finance teams on their toes.

The awkward middle child of structured and unstructured data.

Workflow automation, so you don’t have to babysit data pipelines.

Because not every department deserves full database access.

The secret sauce that makes data searchable, understandable, and actually useful.

Convincing everyone that my version of the dashboard is the truth.

Proof that "we'll fix it later" never actually means later.

“Let’s keep slicing the data until we find something that supports our assumption.”

Turning numbers into narratives people might actually remember.

The legal hoops companies jump through to keep your data kinda safe.

The thing everyone blames but nobody fixes.

Making sure standard data values stay standard—good luck with that.

Handpicking quality data like it’s fine wine.

How much pain your system can handle before collapsing.

A statistical way to check if two things are related or if your data is just messing with you.

Pay a monthly fee to lose your files in someone else’s basement.

The reason your software updates faster than you can blink.

The constant struggle to keep data clean, secure, and useful.

Transforms your bullet point into 40 slides featuring at least two mountain-climbing metaphors.

Moving data from one mess to another.

The illusion of structure in your chaotic data world.

Shipping code faster than your team can fix bugs.

Turning data into a fixed-size mess—useful for passwords, not so great if you ever need to reverse it.

Fake data used for training models when real data is too sensitive, messy, or non-existent.

The family tree of your data, assuming you can track it.

The reason your reports make no sense.

The numbers that make up your analysis—sometimes useful, sometimes just noise.

Because “I think this field means…” shouldn’t be part of data analysis.

The unlucky souls tasked with keeping data under control.

All the missing data that everyone pretends doesn’t exist.

The programming language everyone pretends to know.

Because “I have no idea where this data came from” is not a great answer.

The moment of truth when your model actually makes predictions—hopefully not embarrassingly bad ones.

The delicate art of begging people to care.

We built it for five people and are praying it doesn’t break at ten.

Making sure your servers aren’t crying for no reason.

The art of torturing data until it confesses something useful—or at least makes a nice chart.

Guards their "secret metric" like it's launch codes when it's really just page views in a trench coat.

Lives in a command line, thrives in mayhem. Breaks things just to make them better. Somehow delivers magic at 2 AM.

The IT version of “Ctrl+Z” for disasters.

A bunch of decision trees working together to make better predictions—because one tree alone isn’t enough.

Rules about data that everyone agrees on but nobody follows.

Metadata management to keep track of your ever-growing data jungle.

A checklist of rules to follow… until regulations change again.

Stripping away identities because privacy lawsuits are expensive.

Shows up after work's done to sink regulatory fangs into your launch plans.

“Can you analyze all our data from the last 10 years for a report we’ll ignore?”

A gradient boosting algorithm that wins Kaggle competitions—because sometimes brute force just works.

The frustrations of explaining, again, why two reports don’t match.

Splitting your database into smaller disasters.

Feeding your data pipeline a never-ending buffet.

The fight over who actually controls the data mess.

Making database queries run faster—because no one likes waiting 10 minutes for an SQL query to finish.

When your company trends on Twitter for all the wrong reasons.

The dashboards and reports that will be outdated within a week.

The reason your computer fan sounds like a jet engine.

Machine learning for people who don’t want to do machine learning. Push a button, get a model—hopefully, a good one.

When your model is too smart for its own good and memorizes the training data instead of learning useful patterns.

That thing you forgot to set up before the system crashed.

A table that tells you how often your model gets things right (or, more realistically, how often it screws up).

The "we'll fix it in production" person. They're just one misplaced comma away from getting fired.

A structured way to work with large datasets.

Tweaking a button color and calling it "strategy."

When a relational database is too much effort.

That thing developers ignore until the database breaks.