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

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

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

When processing big data was still cool.

The unlucky souls tasked with keeping data under control.

Finding out where all the secrets are hiding before someone else does.

Deploying apps without touching infrastructure (until something breaks).

Renting someone else’s servers but paying more.

When your AI learns from biased data and makes unfair decisions—because garbage in = garbage out.

Because raw data is just too ugly.

“This data connector technically works, but barely.”

The Costco of structured data.

Automating code merges so your team doesn’t go crazy.

A fancy term for “don’t let hackers steal our stuff.”

The lazy friend of machine learning—it just looks at its closest neighbors and copies them.

Guessing with data—because flipping a coin isn't "data-driven."

Predicting all the ways data can ruin your day.

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

Blueprints for security that companies try to follow.

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

“Yes, our data platform supports SQL. That’s not a selling point.”

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

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

Because finding the right dataset shouldn’t feel like a scavenger hunt.

Hacking yourself before someone else does.

Where structured data goes to drown.

When talking about talking becomes your main deliverable. Bonus points if you can turn it into a self-congratulatory Linkedin post.

Where your data goes to sleep.

The underappreciated hero who turns messy data into charts and makes everyone else look good.

“I haven’t looked at the data yet, but I will… eventually.”

“Will this dashboard break when more than 5 people refresh it at once?”

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

The programming language everyone pretends to know.

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

What you just got assigned because you asked a question in the meeting.

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

When real-time isn’t worth the hassle.

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

Because winging it with data governance isn’t a long-term strategy.

When one team gets credit for your analysis, and you get nothing.

Ignoring that data quality issue until it causes real problems.

The dashboard everyone ignores until an executive asks for it.

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

Goes to every conference and is part of every newsletter. Needs an intervention.

Would slap glitter on a bankruptcy report because "data doesn't pop without gradients!"

Making sense of numbers so businesses can pretend to be data-driven.

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

Slicing and dicing data until it fits your argument.

When your model suddenly starts making terrible predictions because the real world refused to stay the same.

A data point that’s way off from the rest—could be an error, or could be the next big discovery.

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

When leadership changes the KPI goal after you’ve already built the report.

Grouping users to prove that trends aren’t just luck.

Making data look important in executive meetings.

Checking if your security is solid—or just wishful thinking.

Stopping data leaks before they make headlines.

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

Keeping data safe from hackers, leaks, and bad employees.

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

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

Someone else’s computer, but shinier.

A group of overworked data engineers and analysts thrown together to fix a reporting disaster.

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

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

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

Making sure data doesn’t become a dumpster fire.

Like moving houses, but with more downtime and crying.

Keeps the data stack humming so analysts can pretend it’s “just a quick query.”

When bad data leads to even worse decisions.

“Your data reports need to be better, but we won’t give you more resources.”

The theoretical version of your data that reality refuses to match.

Teaching machines to "think" so they can replace humans (but mostly just generate weird chatbot responses).

500 commits in 3 hours. No documentation and no survivors.

Because someone needs to process transactions in real-time.

Just because two things happen together doesn’t mean one caused the other. Like, eating more cheese doesn’t actually make you better at math.

When you want fast answers and minimal thinking.

Tweaking your dataset to improve model performance—because sometimes you need to cheat a little.

Helping engineers understand how data flows, transforms, and actually works.

The science of making sense of data—assuming it’s not lying to you.

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

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

Talking to inanimate objects because humans are worse.

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

Trying to guess the future based on past data—like a digital crystal ball, but with spreadsheets.

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

The key metrics leadership suddenly decided to care about this quarter.

DIY data anarchist whose unholy Excel concoctions somehow hypnotize executives despite breaking every statistical law.

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

A measure of how spread out your data is—basically, how weird or normal your numbers are.

Treats your dashboards like a digital coloring book.

A/B testing’s overachieving cousin.

Deciding where to spend time, money, and energy—usually wrong.

Splitting your database into smaller disasters.

“I don’t trust your analysis, so let’s keep poking at it until it fits my narrative.”

Rules everyone agrees on but nobody follows.

When your data is so bloated no one knows what to do with it, but it sounds impressive.

The reason your database admin hates you.

Redefines success metrics faster than politicians backpedal after an election.

No one understands the report, but we’re pretending we do.

Feeding your data pipeline a never-ending buffet.

Moving data from one mess to another.

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.

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