No SQL? No problem. New no-code joins keep you in the flow of analysis

Most strategic business questions need data from multiple sources — like, Which products are most frequently purchased together? or What channels brought users with the highest lifetime value (LTV)?

Let’s take a specific example — the Head of Growth Marketing wants to understand how churn varies across subscription plans.

They start exploring data and realize they need two different tables, but have questions like: What table do I use? How does the join syntax work? Do I do an inner or outer join? Which columns do I need to join?

Any of these questions can lead our stakeholder right back to the data team’s ticket request queue, pulling them out of their analytics flow and leaving them waiting for answers before they can come to a conclusion on strategy. That’s why, in our recent Explore release, we launched no-code joins — to give our low-code and no-code friends the ability to do joins without knowing SQL or tapping the data team. With intuitive guardrails, our joins let stakeholders stay in the flow of analysis and provide results they can trust.

Smart joins with guardrails

Hex’s no-code joins combine intuitive UI with technical guardrails that keep you from unsuspecting misconfigured results. Now you can start with a point-and-click interface and get suggestions for join keys, warnings about mismatches, and accurate calculations even in the midst of fan-outs (when rows from one of the tables get duplicated through a SQL join). See how it works in our video:

Instead of working through complex SQL queries, just select a table in Hex that has the information you want and hit ‘Join table’ to get started.

Hex is smart enough to suggest join keys — or identify columns that might be good for joining — by using a combination of AI and some good old-fashioned column profiling. It double-checks that the tables relate in a sensible way, kind of like making sure puzzle pieces fit before you try to force them. And here's the best part: it automatically ensures your numbers still come through accurately even when a fan-out occurs.

Basically, it’s like having a data wizard by your side, making joins easier for everyone, whether you know SQL well or are just getting started with data analysis.

Why you might opt for no-code joins in Hex

If you’re not a SQL-pro, there’s a handful of potential speed bumps that can land you back in the data team waiting queue when it comes to SQL-based joins:

1. It’s hard to write code. Writing correct joins is a notoriously difficult aspect of the SQL workflow. It’s not just about understanding the syntax; it requires a strong grasp of relational databases, the structure of the data tables and how they relate.

2. It’s hard to know if columns actually match. A user might see columns like ORDERS.USER_ID and USERS.UUID and assume that they are join keys, but they might be entirely different IDs from disconnected systems that never match. They run the query and get zero rows in the result.

3. It’s hard to make sure tables relate in the way you think they do. Two columns might match up sometimes but not consistently in the way the user was expecting. This will cause the query result to have some data, but not all of it.

4. It’s hard to prevent fan-outs — or multiple matches — when you aggregate joined data. A row from one table might match with multiple rows from the other, based on the join criteria. When this happens in SQL, a new row is created for each match. This is particularly notorious for aggregations, such as `sum(revenue)` or `average(age)`. Careful and experienced SQL writers can avoid these issues by writing some auxiliary queries to check the validity of a join predicate before blindly charging ahead.

Our no-code joins are built so that you have the information to approach the join differently if needed, letting you focus on the analysis at hand.

Other tools have no-code joins. What makes Hex’s different?

The concept of no-code joins might be familiar (which is generally a good thing for curious stakeholders looking to try Hex), but we did two things that most vendors don’t:

1. There's no upfront modeling - No prep or complex modeling is required to do a join. This is helpful because usually by the time you realize you need to do a join, you're already in the middle of an analysis. Our no-code joins can be applied in real-time so you can adjust your data model on-the-fly. With other tools, if you realize mid-analysis that your data model is wrong, you have to start over and do prep and modeling.

(Note: Hex's no-code joins are designed to combine tables during ad hoc data exploration. In some cases, you'll want a more rigorous, curated model that you can re-use across all analyses. Today, Hex can connect to data via dbt's semantic layer and we are working on expanding our semantic sync capabilities to allow LookML and MetricFlow to enhance Explore.)

1. Built-in safety features - With smart join tests, Hex can steer users away from misconfigured joins. Additionally, Hex’s advanced SQL generation logic can maintain accurate aggregations even when a join duplicates rows through a fan-out, keeping you on track for trustworthy results.

No-code joins keep you in the flow of analysis, not in the weeds of SQL

No-code joins help keep analysis flowing, so your data team can focus on insights — not troubleshooting joins. With built-in safety measures, they open up a whole new world of answers and exploration, empowering business users to answer more complex data questions with confidence.

Learn more about Explore and no-code joins at our upcoming live event.