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.
Sifting through data, hoping for something insightful.
The mess left behind when shortcuts meet data analytics.
Would slap glitter on a bankruptcy report because "data doesn't pop without gradients!"
The underappreciated hero who turns messy data into charts and makes everyone else look good.
When your model suddenly starts making terrible predictions because the real world refused to stay the same.
Holding onto data just long enough to avoid legal trouble.
“We ran the same SQL query but indexed a column, so now it’s 2% faster.”
Predicting trends over time—useful for stocks, weather, and figuring out when your Wi-Fi will crash again.
Goes to every conference and is part of every newsletter. Needs an intervention.
Making database queries run faster—because no one likes waiting 10 minutes for an SQL query to finish.
Moving data to the cloud—hopefully without breaking everything.
For when the cloud is just too far away.
Making your inefficient queries slightly less embarrassing.
When you pivot data just to confirm what you already knew.
A free tool for tracking website traffic—until privacy laws step in.
Tweaking and creating data inputs so your model performs better—basically, data science alchemy.
The art of torturing data until it confesses something useful—or at least makes a nice chart.
Shoving a half-baked feature into the project at the last minute.
Protecting user info while secretly monetizing it.
Brings structure to chaos with dbt and a folder hierarchy that could win awards.
A group of overworked data engineers and analysts thrown together to fix a reporting disaster.
Cutting down the number of variables in your dataset—because sometimes, less is more (especially in Excel).
When everyone agrees on what to pretend to care about.
Proof that "we'll fix it later" never actually means later.
Like a Data Lake, but with regret control.
Spotting the oddballs in your data, because sometimes anomalies are fraud, and sometimes they’re just mistakes.
When leadership changes the KPI goal after you’ve already built the report.
When your model is too smart for its own good and memorizes the training data instead of learning useful patterns.
When talking about talking becomes your main deliverable. Bonus points if you can turn it into a self-congratulatory Linkedin post.
Because “I have no idea where this data came from” is not a great answer.
Tweaking the settings of your machine learning model—kind of like adjusting the seasoning in a bad recipe.
The bare minimum dressed up like a competitive edge.
Code for “this could’ve been a Slack message.”
The Data Lake’s evil twin.
Where we test new models and hope no one deploys them to production by accident.
When your system crashes but pretends it never happened.
Shipping code faster than your team can fix bugs.
When two teams argue over whose data is right until they both give up.
“I don’t trust your analysis, so let’s keep poking at it until it fits my narrative.”
The one number we stare at while ignoring the iceberg.
Stripping away identities because privacy lawsuits are expensive.
Making sure data stays trustworthy—or at least looks like it.
Turning monolithic problems into distributed chaos.
Rules everyone agrees on but nobody follows.
A 57-slide PowerPoint where 3 slides actually contain useful charts.
Idea-vomiting buzzword dispenser.
Following data laws just enough to avoid fines.
“This dashboard is broken, but let’s not discuss it in front of leadership.”
This query better finish before the meeting, or I’m in trouble.
The reason your database admin hates you.
The illusion of structure in your chaotic data world.
Invisible data hero who's seen SQL horrors that would make junior devs cry.
“Yes, our data platform supports SQL. That’s not a selling point.”
Transforming categorical data into numerical form—because computers just don’t get words.
Keeps every dataset like it’s a family heirloom but can’t explain where it came from or what it’s for.
The secret sauce behind databases that actually perform.
The difference between well-structured data and a digital black hole.
The legal hoops companies jump through to keep your data kinda safe.
A gradient boosting algorithm that wins Kaggle competitions—because sometimes brute force just works.
Absolute chaos agents.
When real-time isn’t worth the hassle.
Predicting continuous values, like sales figures or how many coffees you'll need to survive Monday.
Because just because you can collect data doesn’t mean you should.
Making sure standard data values stay standard—good luck with that.
The terrifying process of taking your machine learning model from theory to the real world, where it can finally embarrass you.
The endless cycle of finding new ways to blame bad data for bad decisions.
The unlucky souls tasked with keeping data under control.
When economics meets statistics and things get extra nerdy.
500 commits in 3 hours. No documentation and no survivors.
Sharing resources and pretending everything is fine.
Making pretty charts so people think the data makes sense.
Trust no one, verify everything. Paranoia as a security strategy.
A minor data visualization tweak that gets presented as groundbreaking.
Because manually checking your code is for the weak.
When you want fast answers and minimal thinking.
Letting a neural network go crazy with layers upon layers of computation—basically AI's version of overthinking.
Metrics that executives obsess over (but don’t always understand).
How much pain your system can handle before collapsing.
Corporate deity whose random breakfast thoughts outrank your entire research department.
Your code, but only when someone remembers it exists.
We built it for five people and are praying it doesn’t break at ten.
“Let’s keep slicing the data until we find something that supports our assumption.”
The dashboards and reports that will be outdated within a week.
Making data look important in executive meetings.
Europe’s way of reminding companies that data privacy matters.
Organizing data at a scale where things will go wrong.
Human API who communicates in endpoints and considers UIs a moral weakness.
Worships clean metadata and version control. Lives for data lineage and will fight you over naming conventions.
Hacking yourself before someone else does.
Stopping data leaks before they make headlines.
A bunch of decision trees working together to make better predictions—because one tree alone isn’t enough.
Getting access to the full raw data without documentation or guidance.
The reason your software updates faster than you can blink.
The magic behind neural networks—basically, trial and error on steroids until the model gets it right.
Because “whatever naming convention feels right” is not a strategy.
Sorting stuff into categories, like whether an email is spam, a cat is a dog, or your AI is actually working.
Turns their poor planning into your emergency with Slack messages that induce cardiac events.
Making sense of numbers so businesses can pretend to be data-driven.
Keeping unauthorized users out - until someone shares a password.
A fragile house of cards filled with hidden errors, broken formulas, and misplaced decimal points.
Urban data dictionary powered by
