Enterprise Data Discovery / Logistics

Helping operations teams find and use governed data without SQL

The customer asked for help making SQL easier for employees. Query syntax was not the first barrier: operators did not know what data existed, where it lived, or what to search for. I joined the project midway — two weeks before its beta test — and worked on-site as the FDE, translating customer requirements directly into the product and the code. We completed the 200-user beta, and I continue to build the portal’s data-governance workflow.

Beta completed · enterprise rollout and governance in progress Joined 2 weeks before betaPrimary on-site FDE20+ person multi-party delivery
200users

Beta test completed

2weeks

From joining the project to beta

5of 20+

Upflow engineers on the delivery

350Mrecords

Connected through Databricks, represented in the portal

On this page
  1. 01Project snapshot
  2. 02What I owned
  3. 03The initial request
  4. 04Problem discovery: a screen that worked and still failed
  5. 05Constraints that shaped the product
  6. 06Key decisions
  7. 07Service architecture
  8. 08Query Builder — the flow I implemented
  9. 09Implementation and iteration
  10. 10Outcome — and what is not done
  11. 11What I learned
01

Project snapshot

CustomerMajor Korean logistics enterprise (anonymised)
UsersOperations employees without SQL expertise
DurationMarch–October. Joined midway, two weeks before beta testing
Team20+ people across the full project; 5 from Upflow
My roleOn-site FDE and customer-facing engineer: requirements, hands-on implementation, product iteration, cross-company coordination
EnvironmentDatabricks · Power BI · Databricks-hosted LLM API
Delivery shapeCustomer, prime SI, platform and governance partners, and Upflow
Status200-user beta completed; governance and enterprise expansion in progress
02

What I owned

As the on-site FDE, I was the direct technical contact for customer requirements. I implemented most changes requested through customer feedback, with direct ownership of the search-results upgrade, the data-governance features, and the detailed Query Builder interactions.

BuiltUpgraded search-results experience and the detailed Query Builder interactions — designed and implemented by me.
BuiltThe portal’s data-governance workflow, from quality signal to administrator correction. Currently in development, owned end to end.
BuiltTranslating requirements and feedback from the customer site into product and engineering decisions.
CoordinatedPortal, Databricks and partner-owned layers across a 20+ person delivery team.
CoordinatedPower BI delivery — I oversaw the work and bridged the customer and the modeler. I did not personally build the reports.
03

The initial request

“Our employees cannot use SQL. Help them access and use the data.”

Customer, project kickoff

The request assumed that SQL syntax was the bottleneck. But writing a query only helps after a user knows which data exists, understands how it is organised, and can decide what to ask for.

The real gap appeared earlier in the workflow. Operators needed a way to discover and understand the available data before they could query it.

Initial framingMake SQL easier for non-technical employees.
What the workflow revealedUsers did not have a clear starting point for finding the right data.
Product definitionBuild a discovery layer between the governed data platform and the people trying to use it.
04

Problem discovery: a screen that worked and still failed

The first version reached the 200-user beta. Then I received direct feedback that the results screen did not communicate enough context.

“We can tell the portal is trying to provide a lot of data, but we cannot tell what information is available or what the screen is trying to show us.”

Beta user feedback, paraphrased

The screen returned data, but users could not understand what they were looking at or how each result related to the wider structure. To identify the cause rather than patch the visible symptoms, I used and compared other data-search products myself. That research showed how hierarchy, filtering and result context reduce the user’s interpretation burden. I used those findings to define the improvement direction and rebuilt the experience.

Search results — before and after the rebuild
portal / search
TB_DLV_001shipment_id, dlv_dt, ctr_no, org_cd … 48 columns
TB_DLV_014dlv_seq, org_cd, dest_cd, sts_cd … 31 columns
VW_DLV_SUM_Myyyymm, org_cd, qty, amt … 12 columns
TB_DLV_HISTdlv_seq, chg_dt, bef_sts, aft_sts … 22 columns
TB_DLV_EXCPdlv_seq, excp_cd, rmk … 17 columns
Everything matching the word, ranked by nothing the user could see. No hierarchy, no ownership, no freshness, no way to tell two similar tables apart.
portal / discover
Data domains
  • Logistics128
  • Delivery36
  • Warehouse44
  • Transport48
  • Finance57
  • Customer39
Certified onlyUpdated < 24hHas data owner
Logistics Delivery Daily
Delivery status (daily)
One row per delivery per day, standardised from four source systems.
CertifiedOwner: Ops data teamUpdated 04:101.2M rows
Logistics Delivery Exceptions
Delivery exceptions
Delayed, failed and re-attempted deliveries with reason codes.
CertifiedOwner: Ops data teamUpdated 04:1084K rows
Logistics Delivery Monthly
Delivery volume (monthly)
Aggregated view used by the embedded Power BI report.
Report sourceUpdated monthly96K rows
Guided exploration: the user narrows a domain, sees where each result sits, and reads governance context before deciding to open it.
Reconstructed with substitute data — no customer datasets, names or identifiers appear here. The change was not visual polish: the same query now answers “where am I, what is this, and can I trust it?” before the user opens anything.
  • From a result-first screen to guided exploration.
  • From flat search results to hierarchy and filtering.
  • From assuming users knew the catalog to showing where each result belonged.
05

Constraints that shaped the product

This was not a greenfield application. The solution had to fit into an existing enterprise environment.

  • The Databricks platform already existed and was maintained by a partner team.
  • Data governance and access boundaries could not be bypassed by the portal.
  • The primary users were operators, not analysts or engineers.
  • Several companies owned different layers of the delivery, so technical and organisational boundaries had to stay explicit.
  • I joined two weeks before beta testing, so I had to understand the existing code and customer context while delivering against an immediate deadline.
  • The first release had to support 200 users while remaining compatible with a wider enterprise rollout.

My team owned the portal layer and Power BI delivery. We did not replace the Databricks platform. I owned the portal’s technical direction and hands-on implementation while coordinating the report work between the customer and our modeler. That boundary kept the product focused and made responsibilities legible across the delivery team.

06

Key decisions

01Build a discovery layer, not a SQL training tool

I treated the customer’s request as a starting point rather than the specification. Instead of optimising first for query generation, I organised the product around discovering what data was available and narrowing it to something understandable.

This shifted the primary experience from “write a better query” to “find the right place to begin”.

trade-offQuery generation shipped later and stayed a PoC. Accepted: discovery unblocked more users, sooner.
02Replace the first search-results experience instead of patching it

The first version reached beta, but users could not read the results. Rather than adjusting the screen, I researched other data-search products to find why the structure failed, then rebuilt the information architecture around hierarchy, filtering and result context.

trade-offRework during an active beta. Accepted: the alternative was a functional screen nobody could use.
03Keep ownership boundaries visible in the architecture

The portal connects to standardised information in Databricks and presents it in a form operations users can navigate. Curated Gold Mart datasets feed Power BI reports, which are embedded back into the portal. The portal adds the user-facing discovery, query, report and governance experiences without replacing the underlying data platform.

This was both a technical and a delivery decision. In a multi-party enterprise project, unclear ownership becomes a system risk.

trade-offLess freedom to change platform behaviour. Accepted: clear seams between four organisations.
04Treat natural-language query generation as a PoC — and say so

The Query Builder uses a Databricks-hosted LLM to generate a query from a user’s intent. The user can review the query, execute it against Databricks, inspect the returned data in the portal, and export the result to Excel.

The end-to-end workflow works, but the current PoC does not yet include the production-grade validation layer needed to verify generated queries before broader use. That validation must be designed alongside the generator before the feature can be called complete.

trade-offMarked PoC rather than shipped. Accepted: an unvalidated generated query against governed data is a governance failure, not a feature.
05Turn data quality into an operational governance workflow

The governance work is not only a dashboard of quality metrics. Databricks data is assessed for standardisation quality and contamination, and governance administrators need a repeatable way to review issues and correct them through the portal.

I own this feature area end to end. The workflow connects data-quality signals to administrator review and correction, making standardisation something the organisation can operate rather than a one-time data-cleaning task.

trade-offLarger scope than a metrics dashboard. Accepted: a dashboard reports the problem, a workflow closes it.
07

Service architecture

Portal, Databricks, Power BI — and who owns what
Portal, Databricks, Power BI — and who owns whatOperationsusers (no SQL)GovernanceadministratorsData portalHierarchy, search, filtersQuery BuilderPoC — no validation layer yetResults view + Excel exportGovernance workflowin developmentGovernance & access controlsStandardised data (Databricks)Gold Mart — curated datasetsDatabricks-hosted LLM APIQuality & contamination signalsPower BI reports — coordinated by me, built by our modelersearchexecutegeneratequeryresultsquality signalcorrectembedded
Built by meCoordinated by meExisting / partner-owned
The portal is deliberately positioned as the user-facing discovery and interaction layer. Connected data is standardised in Databricks and presented through the portal. Gold Mart datasets support Power BI reports, produced by our team and embedded in the portal — I oversee that work and connect the customer with the modeler rather than building the reports myself.

The Query Builder covers the full user flow from query generation and execution to viewing and exporting results. Its remaining gap is query validation, not execution. The governance workflow measures quality and contamination signals from Databricks, presents them to governance administrators, and supports a managed correction process through the portal.

Governance workflow — signal to correction
Governance workflow — signal to correctionQuality measuredstandardisation, contaminationAdministrator reviewin the portalCorrection appliedstandardisation fixedPlatform data updatednext measurement changesthe loop is the point
In development. The point of the loop is that a correction re-enters the platform and changes the next measurement, so standardisation becomes an operated process rather than a cleanup project.
08

Query Builder — the flow I implemented

Intent → query → execution → result → Excel
Step 1 · Intent

The user describes the question

No SQL required at the entry point. The intent is captured in the user’s own words, inside the dataset they already narrowed to during discovery.

Ask about this dataset
1 / 5
Reconstructed with substitute data. Step 2 is where the PoC boundary sits: the user reviews the generated query because the system does not yet validate it.
09

Implementation and iteration

Beta − 2 weeks

Joined the project on-site

Took over customer-requested development while reading an existing codebase and an in-flight customer relationship.

Beta − 2 weeks

Reframed the request

The SQL request became a data-discovery problem, which changed what the first release had to prove.

Beta

200-user beta completed

Delivered with the wider project team across four organisations.

Beta + days

The feedback that mattered

“A lot of data, but we cannot tell what is available.” A technically correct screen was failing.

Post-beta

Cause analysis, not patching

Used competing data-search products directly to find why the structure failed, then defined the improvement direction.

Post-beta

Rebuilt the results experience

Hierarchy, filtering and result context, implemented by me.

Post-beta

Query Builder end to end

Generation, review, execution, results and Excel export.

Ongoing

Governance workflow

Quality measurement, administrator review and standardisation correction — owned end to end, still in development.

The most important iteration was not technical

It was recognising that a technically functional result screen still failed if users could not understand the result. That is a product judgement, and it only surfaced because I was on-site to hear it said plainly.

10

Outcome — and what is not done

Completed

  • Joined two weeks before beta and helped complete the 200-user beta.
  • Standardised Databricks data represented in the portal, with the platform boundary preserved.
  • Power BI reports built from curated Gold Mart datasets, embedded in the portal.
  • Query Builder: generation, execution, Databricks results and Excel export.

In progress

  • Enterprise-wide expansion.
  • The data-governance workflow — measurement, administrator review, correction.

Explicit limits

  • The Query Builder is a PoC: no production-grade query validation layer yet.
  • User satisfaction has not been measured.
  • The ~350M records describe data connected through the platform, not records created or processed by the portal.
  • This case demonstrates a successful 200-user beta, not a completed company-wide deployment.
11

What I learned

The initial request often describes the nearest visible obstacle, not the underlying workflow problem. Here, SQL was visible — but discoverability came first.

If I ran the project again, I would put a stripped-down results experience in front of five operators during the first week, to test whether users understood the information structure before the team invested in a wider rollout. I would also design query validation at the same time as generation, rather than treating it as a later production concern.

Diagrams are drawn from the real systems and redrawn here; customer names, data and identifiers are removed.