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

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.

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

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

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

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

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

Trying to convince non-technical people that data matters.

Your code, but only when someone remembers it exists.

Sifting through data, hoping for something insightful.

Getting the most out of your budget before the CFO notices.

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

The difference between well-structured data and a digital black hole.

When you can’t commit to a single cloud provider.

The reason your reports make no sense.

Because mistakes were made.

Because “whatever naming convention feels right” is not a strategy.

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

A central place for data that everyone fights over.

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

SQL’s rebellious younger sibling.

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

Rules about data that everyone agrees on but nobody follows.

The behind-the-scenes data that keeps everything (barely) organized.

Translating raw data into real-world meaning so it’s actually useful.

The one dashboard we all agreed on… until someone else made a new one with different numbers.

A flowchart-like model that makes decisions—think "choose your own adventure" but with math.

Code for “this could’ve been a Slack message.”

Moving data to the cloud—hopefully without breaking everything.

The never-ending battle between hackers and IT teams running on coffee.

“We need to filter this data in every way possible until it agrees with us.”

Teaching computers to recognize patterns so they can pretend to be smart—until they overfit and fail.

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

Because manually moving data is for people who hate themselves.

Turning numbers into narratives people might actually remember.

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

Because just because you can collect data doesn’t mean you should.

Retiring an old dashboard but keeping the dataset running ‘just in case.’

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

Handpicking quality data like it’s fine wine.

A free tool for tracking website traffic—until privacy laws step in.

Human API who communicates in endpoints and considers UIs a moral weakness.

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

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

Double-checking data before it makes a fool of you.

Saving progress so your system can crash at a later, more inconvenient time.

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

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

When bad data leads to even worse decisions.

The magic that makes your slow queries slightly less slow.

Poking around in your data to find trends, outliers, and problems before they ruin your model.

The programming language everyone pretends to know.

“This data connector technically works, but barely.”

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

The reason your software updates faster than you can blink.

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

Sorting stuff into categories, like whether an email is spam, a cat is a dog, or your AI is actually working.

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

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

Schedules pre-meetings for the pre-meeting's pre-brief because they couldn't read an email to save their life.

Creates JIRA tickets to track their JIRA tickets while drowning in chaos.

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

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

Because not every department deserves full database access.

How much pain your system can handle before collapsing.

The awkward middle child of structured and unstructured data.

“We made a pretty chart—please pretend it changed your decision-making.”

The go-to event for data professionals who want to rethink how governance is done. Join experts reimagining the future of what AI-readiness looks like

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

Stalking customers, but make it “data-driven.”

“Here’s what you should do, but no one actually follows.”

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

Keeping secrets… until someone forgets to lock the database.

Checking your data before it embarrasses you.

Granting permissions based on job roles, not personal favorites.

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

The alarm system for when hackers come knocking.

Fluent in stakeholder management, and can turn vague requests into scarily accurate dashboards. Built half the team's workflows on vibes and somehow made it work.

A digital breadcrumb trail for when things inevitably go wrong.

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

Feeding your data pipeline a never-ending buffet.

Transforming categorical data into numerical form—because computers just don’t get words.

When everyone agrees on what to pretend to care about.

Tweaking the settings of your machine learning model—kind of like adjusting the seasoning in a bad recipe.

Training models on decentralized data—because sharing is caring, but privacy lawsuits are expensive.

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

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

Scrambling data so only the right people (hopefully) can read it.

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

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

Holding onto data just long enough to avoid legal trouble.

Because well-managed data is the difference between insights and chaos.

Telling you whether your results matter or if they’re just a fluke—like winning the lottery.

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

Splitting your database into smaller disasters.

The reason healthcare companies fear data leaks.

The terrifying process of taking your machine learning model from theory to the real world, where it can finally embarrass you.

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

Because reading rows one at a time is for chumps.

The fine art of deciding who gets in and who gets a "403 Forbidden."

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

The awkward silence between launch and someone actually using it.