rss.livelink.posts-in-node

Re: FAQ for Advanced Learning Festival September 16 - October 14 2026

keerthanaa — Wed, 02 Sep 2026 03:23:45 GMT

Am I eligible to receive the voucher if I complete the free, self-paced courses in the chosen learning pathway, or is completing an instructor-led course required?

Re: MuleGraph Investigator: Uncovering Money Mule Networks with Databricks Genie

niteshm — Wed, 02 Sep 2026 03:23:01 GMT

See attached for the demo.

All 18 Lakeflow AUTO CDC configurations went green. Five failed my ship check

ivanvyd — Wed, 02 Sep 2026 01:54:46 GMT

Paper event slips trace 18 Lakeflow AUTO CDC configurations: 13 stay on the main sequence while five branch into production stop signs.

Change data capture (CDC) keeps a downstream table in step with row-level inserts, updates, and deletes instead of reloading the whole source. Lakeflow AUTO CDC handles the state-management work, including sequencing, deletes, and SCD history. It still needs a precise source contract: which clock wins, how ties break, what NULL means, and which changes deserve history.

I built this experiment to see what happens when source data is late, duplicated, contradictory, or noisy, and to separate a pipeline that finishes from a target I would trust. The suite pushes nine hostile CDC patterns across 13 isolated source tables and 18 AUTO CDC configurations: duplicates, late events, tied sequence values, conflicting clocks, sparse NULL updates, deletes, replays, sync-noise updates, and bitemporal corrections.

All 18 configurations completed. Five green configurations failed my ship check: three had complete ordering but violated the stated business rule, and two used incomplete ordering.

Start with scenario 4. Ordering the same rows by ingestion time kept ACTIVE; source event time produced SUSPENDED, the expected business state. Both configurations finished green.

I used pipeline status to confirm execution. I used target-state assertions to decide whether I would ship.

Independent experiment. I ran this test for my own engineering work. It is not official Databricks guidance. I’m happy to discuss your results, feedback, and the failure modes you think I missed.

Run the experiment · Inspect the result matrix

Results in one minute

10 handled: keep the sequence rule and test it against your source.
3 configuration-dependent: set the option that matches the business rule.
3 business-semantics stops: change the chosen clock, NULL meaning, or history policy.
2 ambiguous-order stops: add a source-side tie-breaker.

Execution stayed green across all five stop signs. Source semantics or ordering failed my ship check.

The five stop signs

Configuration Measured result Fix before production

3A Sequence collision	Two business states shared one sequence value. The contract names no winner.	Reject ties or add a stable source-side tie-breaker.
3B Tie-breaker ignored	The source supplied transaction_sequence, but the flow left it out of SEQUENCE BY.	Use a composite sequence.
4A Ingestion-time order	The target kept ACTIVE; source time required SUSPENDED.	Use the clock that defines business recency.
5A Default NULL handling	A sparse update replaced the existing email with NULL.	Define NULL semantics and use IGNORE NULL UPDATES when NULL means absent.
8A Track every column	Fifty sync-timestamp updates created 51 SCD2 rows.	Exclude operational metadata from history tracking.

The other 13 configurations matched the experiment’s business rule under a complete order and the required option.

How I tested it

The generator creates small, isolated source tables with one failure mode per scenario. One pipeline wraps each source in a streaming view and runs all 18 AUTO CDC configurations.

For late events and replays, I ran two updates. The full refresh established a baseline. The incremental update appended the withheld rows. The verifier required the two expected histories to change, the other 16 targets to remain equal, and every target to match its row-count and observed-state predicate. The final classification combined those measurements with the declared ordering and business-rule labels.

You can inspect the code in src/pipeline/pipeline.py and src/generators/dispatch.py. The result matrix and captured target rows carry the measured evidence. Official Databricks documentation used for the platform claims is indexed in docs/sources.md.

Four source decisions that change the answer

1. Pick the clock that means “newer”

The generator emits two events for the same key:

10:00 source time  ACTIVE
10:05 source time  SUSPENDED

Their ingestion timestamps reverse that order. Ordering by ingested_at keeps ACTIVE. Ordering by source_updated_at produces SUSPENDED, which matches the experiment’s business rule.

Two AUTO CDC targets show that ingestion time misses the business expectation while source time matches it.

Two AUTO CDC targets use the same rows and schema. The sequence clock changes the answer.

Arrival time helps you analyze transport; source time can define business recency. Pick the column from the business definition before you write the flow.

2. Give ties a real winner

The collision pattern gives two states the same source_sequence:

seq=10  status=ACTIVE
seq=10  status=SUSPENDED

I observed SUSPENDED, but the configured order cannot distinguish the rows, so I recorded the result as AMBIGUOUS_ORDER.

The source also provides transaction_sequence. A composite sequence such as STRUCT(source_updated_at, transaction_sequence) gives the flow a stable order. The composite configuration produced the expected SUSPENDED state, and the verifier classified it as HANDLED.

3. Decide what NULL means

The sparse-update pattern begins with email='x@example.com'. The next event updates the city and carries email=NULL.

The default configuration sets the target email to NULL. IGNORE NULL UPDATES keeps the existing email. Both behaviors can serve a valid source contract. Your producer must define whether NULL means “erase this value” or “this field was absent.”

4. Keep sync noise out of business history

The history-noise generator emits 50 updates. Among the retained target columns, only last_synced_at changes.

Tracking every included target column creates 51 SCD2 rows. Excluding last_synced_at creates one row because the business fields never change.

Tracking every included target column produces 51 SCD2 rows; excluding last_synced_at produces one.

Operational sync metadata accounts for all 50 extra versions.

Choose the columns that represent business history before you deploy SCD2. Whether operational changes belong there is a domain and audit decision; this experiment’s business rule counted only business-field changes.

Patterns AUTO CDC handled

Pattern Measured result

Identical duplicate and late replay	SCD1 kept one ACTIVE row. The replay left visible state unchanged.
Out-of-order update	SCD1 kept the newer state. SCD2 inserted the older event as a closed history row.
Delete followed by an older event	SCD1 kept the deletion. SCD2 inserted the late state before the delete boundary.
Full lifecycle replay	SCD1 and SCD2 matched their saved baselines after the replay.
Bitemporal correction	The target preserved business time and system time across five measured rows.

These are visible-state observations from appended replays. They do not establish transactional deduplication or test a checkpoint-only restart with no new source rows.

Bitemporal kept both clocks

Scenario 9 uses source_updated_at for business time and ingested_at for system time. The target stores __START_AT / __END_AT beside __SYSTEM_START_AT / __SYSTEM_END_AT.

Three events produced five rows because later ingestion times revised earlier valid-time intervals.

Five measured bitemporal rows show original and revised valid-time intervals across three system times.

Five rows preserve the original and revised valid-time intervals.

Databricks marks bitemporal storage as Beta. This run validates five tiny rows and does not test load. I would evaluate it when valid time differs from ingest time and consumers need as-of-system-time queries.

The full result map

All 18 measured configurations grouped by handled, configuration-dependent, business-semantics, and ambiguous-order outcomes.

All 18 measured configurations grouped by production outcome.

You can inspect the machine-readable matrix in results/normalized/summary_matrix.json and the captured rows in results/raw/target_state.json.

My production checklist

Name the business clock. Put the column that defines recency in SEQUENCE BY.
Search for ties per key. Add a source-side tie-breaker when two states can share one sequence value.
Write down NULL semantics. Use IGNORE NULL UPDATES only when NULL means absent.
Choose the state model. SCD1 keeps current state; SCD2 keeps ordered history.
Filter history noise. Exclude sync metadata unless it represents a business event.

Add a target-state predicate for each rule: update status checks execution, while the predicate checks the expected target state.

Reproduce the run

git clone https://github.com/ivanvyd/lakeflow-auto-cdc-torture-test.git
cd lakeflow-auto-cdc-torture-test
python -m pip install -e ".[dev]"
databricks auth login --host https://<workspace-url> --profile DEFAULT
make setup
make test
make results

You need Python 3.10 or newer, GNU Make, jq, the Databricks CLI, and access to a Databricks workspace. The reproduction guide covers the one-time setup and evidence capture.

Sixteen targets matched their baselines after update 2. The two SCD2 targets that received late history changed as expected. The verifier checked all 18 targets and produced 10 HANDLED, 3 CONFIGURATION_DEPENDENT, 3 BUSINESS_SEMANTICS, and 2 AMBIGUOUS_ORDER results.

The checked-in result set was captured on 2026-09-01 from clean commit 01d53b4; target_state.json records the pipeline and both update IDs.

Scope

This suite uses tiny controlled datasets. I did not test throughput, backpressure, or large joins. Each flow read one isolated source table; I did not test joins or interactions across streams. The delete-and-late-event case stayed inside the configured 48-hour tombstone-retention window. Bitemporal load behavior also sits outside this run.

The evidence comes from one workspace, one SQL warehouse, one customer key, serverless Advanced-edition compute on the CURRENT channel, and tiny deterministic inputs. Use separate tests for throughput, schema evolution, and multi-stream joins.

Bring your failure mode

Clone the repository and replace one generator with an event sequence from your source. Add the expected target state, run both phases, and compare the capture.

If the suite misses your case, open an issue with the source rows, SEQUENCE BY expression, storage type, expected target, and observed target. I’m happy to turn a clear failure report into another reproducible scenario.

Lakebase Postgre updating Delta Table.

rkhbo3003 — Wed, 02 Sep 2026 01:44:54 GMT

I am using Postgre for OLTP processing for POS application.Lag is reduced a lot, however when there is updation on Postgre table, I need to sync back to delta table. There is one way from delta table sync table (read only). Any design pattern sas to keep delta table and postgre table in sync.

From Semantic Similarity to Business Authority: Why Genie Ontology and OntoRank Matter

amitsharma1707 — Wed, 02 Sep 2026 00:59:50 GMT

Enterprise AI does not usually fail because the model lacks intelligence.

It fails because the model does not understand what the organization means.

Consider a simple question:

“What is our current exposure to active customer?”

Behind this question are several business decisions:

What qualifies as an “active” customer?

Should exposure include committed, outstanding, or available amounts?

Which customer identifier is authoritative?

Should rebooked amount be consolidated?

Which system is trusted: the servicing platform, CRM, MDM golden record, or a reporting mart?

What business date should be used?

A traditional text-to-SQL system may identify tables with similar column names and generate syntactically correct SQL. But syntactically correct SQL can still produce a completely incorrect business answer.

This is the context gap that Databricks Genie Ontology is designed to address.

What is Genie Ontology?
Genie Ontology is a unified, continuously improving context layer that gives Genie a business-aware map of the organization.

It combines:

Human-modeled context

Certified data products, Unity Catalog metric views, domains, business definitions, Pages, and governed assets.

Automatically inferred context

Knowledge extracted from tables, queries, dashboards, SQL patterns, Genie Agents, and platform usage.

Instead of treating enterprise knowledge as disconnected metadata, the ontology represents relationships among:

Business terms

Metrics

tables and columns

dashboards

queries

data products

people and teams

business rules

Genie Agents

This changes the question from:

“Which asset looks most similar to the user’s prompt?”

to:

“Which permitted source represents the most authoritative meaning for this question?”

Where OntoRank becomes important
Enterprises rarely have only one definition of a metric.

There may be multiple definitions of revenue, customer, active account, gross margin, or credit exposure—each created by different teams, at different times, for different purposes.

OntoRank is the PageRank-inspired authority-ranking concept associated with Genie Ontology.

Rather than ranking only by textual similarity, the context layer can consider signals such as:

Source authority and provenance

Asset certification

Frequency and breadth of usage

Relationships with other trusted assets

Freshness

Business relevance

User permissions

For example, imagine Genie discovers three definitions of “active customer”:

An old spreadsheet definition created three years ago

A frequently queried but uncertified reporting view

A certified Unity Catalog metric connected to the MDM golden customer and current amount balances

Keyword similarity alone might retrieve any of them.

An authority-aware approach should prioritize the certified, governed, fresh, and widely connected definition—while still enforcing the requesting user’s permissions.

Why this is bigger than better text-to-SQL
The real architectural shift is:

Metadata → Semantics → Context → Trusted action

A well-designed ontology can help an AI system understand:

Which source should be queried

Which metric definition should be applied

Which relationships and joins are valid

Which conflicting definition should take precedence

Which assets are deprecated

What the user is authorized to access

Why a particular source was used

This can make AI systems more accurate, explainable, reusable, and governance-aware.

But OntoRank does not eliminate data governance
Authority ranking is powerful, but popularity is not always correctness.

A widely used definition may still be outdated. A newly created certified data product may initially have little usage history. Poorly documented tables will continue to produce weak context.

Therefore, organizations should prepare the foundation:

Define important business terms

Create governed metric views

Certify authoritative data products

Deprecate obsolete assets

Maintain table and column descriptions

Capture lineage

Assign clear data ownership

Improve MDM and identity resolution

Test Genie answers against approved business scenarios

Genie Ontology can amplify a strong semantic and governance foundation—but it cannot magically repair an undefined business vocabulary.

My key takeaway
The next generation of enterprise AI will not be differentiated only by model size.

It will be differentiated by the quality of the context surrounding the model.

RAG helps AI find similar information.
Ontology helps AI understand relationships and meaning.
OntoRank helps AI decide what should be trusted.
Unity Catalog helps ensure that trust remains governed.

The most important question for data architects may soon change from:

“How do we expose our data to an AI agent?”

to:

“How do we make business meaning discoverable, authoritative, permission-aware, and machine-readable?”

I would love to hear from the Databricks Community:

How are you preparing your Unity Catalog metadata and metric views for Genie Ontology?

How should OntoRank balance popularity against formal certification?

Should users be able to inspect the ontology graph and understand why one definition outranked another?

What evaluation framework are you using to measure the business accuracy of Genie answers?

Re: Unable to change password on Webassesor

niteshm — Tue, 01 Sep 2026 23:45:29 GMT

Is this issue resolved?

Partitioning vs Liquid Clustering (per-table):

AshokB — Tue, 01 Sep 2026 20:16:23 GMT

Can PARTITION BY and CLUSTER BY (Liquid Clustering) be used simultaneously on the same table? If we use only PARTITION BY, is there a negative performance impact on materialized-view refreshes in Silver/Gold? Since materialized views read only incremental delta files, is Liquid Clustering redundant in this scenario, or does it still provide benefits for file compaction and read optimization?

Re: Building a Databricks Solutions Architect Genie Agent

saketsuman — Tue, 01 Sep 2026 20:12:42 GMT

Re: Research It!

saketsuman — Tue, 01 Sep 2026 20:03:49 GMT

Re: Streaming tables fail with DELTA_STREAMING_INCOMPATIBLE_SCHEMA_CHANGE_USE_SCHEMA_LOG after addin

AbhilashNagilla — Tue, 01 Sep 2026 19:01:45 GMT

The error confirms that the silver Delta stream encountered a schema transition it considers read-incompatible. It does not identify the original SQL Server DDL, so I would verify the sequence before assigning a root cause.

Lakeflow Connect normally ingests a new source column on the next pipeline run. Some SQL Server changes require a full refresh, including column renames, datatype changes, and column additions with default values. A Connect full refresh can also span multiple updates: bronze keeps its old data while the new snapshot is built, then Databricks applies the snapshot and accumulated CDC records in one atomic update.

That timing gives one plausible explanation for what you saw: silver may have been fully refreshed before the new bronze snapshot was applied, then encountered the changed bronze schema on its next update. The thread does not prove that explanation, however.

I would check:

The ingestion pipeline update history and event log to identify the update in which the bronze full refresh was applied.
DESCRIBE HISTORY <bronze_table> for the table versions, operations, and timestamps around that update.
The silver event log to confirm its full refresh completed after the bronze update.

For schemaTrackingLocation, pipeline checkpoints are internal and are not directly accessible. I would not manually delete or assign a checkpoint path. After the bronze full refresh has been atomically applied, fully refresh the affected silver streaming table. If it still fails, open a support case with the bronze history and both pipeline event logs. A selective checkpoint reset is also documented, but for a Delta source it requires a correct startingVersion and replay-safe target logic to avoid loss or duplication.

One separate design point: SCD Type 1 changes update existing bronze rows. Use skipChangeCommits only if silver may intentionally ignore those updates. If silver must receive them, consume the bronze change data feed and apply the changes with AUTO CDC, or use a materialized view when current-state results are sufficient.

Making Databricks Genie Spaces Actually Work: A Practical Framework for Client and Data Teams

Salman_Ahmed — Tue, 01 Sep 2026 18:42:28 GMT

Introduction

Over the past year, I've had quite a few conversations with teams exploring Databricks Genie Spaces. The pattern is usually the same. Someone sees a demo, watches a business user ask a question in plain English, and within seconds Genie returns a chart, a SQL query, and what appears to be a perfectly reasonable answer.

The reaction is almost always immediate.

"This could completely change how people use data and BI reports."

For years we've built dashboards, semantic models, reporting layers, and self-service analytics platforms with the goal of helping business users answer questions faster. Genie feels like the natural next step in that journey. Instead of learning SQL or navigating dozens of dashboards, users can simply ask a question and interact with data conversationally.

The technology itself is impressive. But after working on enterprise data platforms for many years, the challenge is rarely the AI model itself.

The challenge is trust.

Can users trust the answer? Can analysts reproduce it? Can data teams explain it? And perhaps most importantly, will different users receive consistent answers to the same question?

Those questions have far less to do with the language model and much more to do with the foundation underneath it. That's why whenever I'm asked how to improve Genie Spaces.

I rarely start by talking about prompts, I start by talking about data.

Why Most Genie Projects Fail Before Users Ask Their First Question

When teams evaluate Genie Spaces, their first instinct is often to improve prompts or add more instructions.

In my experience, that's usually the wrong starting point. Most quality issues originate from one of five areas:

Weak data modeling (Data Engineering)
Poor metadata quality (Data Scientist/Business Analyst/Data Analyst)
Undefined business metrics (Data Scientist)
Missing table relationships (Data Engineering)
Lack of benchmark testing (ML Engineer)

Databricks has been investing heavily in a governed semantic foundation through Unity Catalog Semantics, Genie Ontology, Live Tables, including metric views, domains, governed business definitions, and AI-aware context management. These capabilities help ensure that both humans and AI systems interpret data consistently.

Step-by-step plan

Step 1: Build the Data Foundation Before Building the Genie Space

The single most important success factor is the quality of the curated data layer.

Many data teams expose highly normalized source models and expect Genie to figure out the relationships. While technically possible, this often introduces ambiguity. Instead, design datasets specifically for consumption.

Recommended Design Approach

1. Denormalize Where Appropriate

Rather than expecting Genie to navigate a maze of joins every time a user asks a question, it's worth investing in curated business-ready delta tables. If answering a simple revenue question requires six or seven tables to be stitched together, the chances of selecting an incorrect relationship increase significantly. In most successful implementations I've seen, common dimensions are already joined, business entities are standardised, and duplicate relationship paths have been removed long before the data reaches Genie.

2. Pre-Calculate Common Business Logic

A common mistake is treating Genie as the place where business logic should be assembled. In reality, repetitive calculations and classifications belong in the data layer. Whether it's reporting periods, fiscal calendars, active customer definitions, or product lifecycle states, these concepts should already exist in a governed and reusable form. This allows Genie to focus on answering the question rather than reconstructing business logic every time.

3. Establish Canonical Metrics

One of the strongest capabilities available through Unity Catalog is the ability to define reusable metrics and semantic objects that provide consistent business logic across analytics workloads and AI consumers.

For example:

measures: - name: Total Revenue expr: SUM(purchase_amount) FILTER (WHERE status='approved') comment: Revenue from approved transactions display_name: Total Revenue synonyms: - revenue - sales - total sales - approved revenue

This ensures that every user asking about revenue receives answers based on the same calculation.

Step 2: Treat Genie Like Software and Create Benchmarks

I've been in sessions where a team asks Genie three questions, gets two correct answers, one questionable result, and immediately starts debating whether the prompt needs to be rewritten. The reality is that this kind of testing is far too subjective. Without a defined set of benchmark questions and expected outcomes, it's almost impossible to measure quality in a meaningful way. That's why it is best to establish a benchmark suite early, before wider adoption begins.

Create a Question Inventory

The best benchmark questions usually come directly from the people who use the data every day. Spend time with business stakeholders, analysts, and subject matter experts to understand the questions they regularly ask, whether that's tracking KPIs, understanding trends, explaining variances, or preparing executive reporting. Once you've collected those questions, document what a correct answer looks like. That includes not only the expected result, but also the level of aggregation, any business filters that should be applied, and how the answer should be presented. The goal isn't simply to test whether Genie returns an answer. It's to verify that the answer aligns with how the business expects the question to be interpreted.

Build a Regression Test Suite

A Genie Space is never really finished. The underlying data platform keeps evolving, new business requirements appear, and teams continuously refine their definitions and metrics. While those changes are important, they also introduce risk. I've found that the most successful teams maintain a set of benchmark questions that are executed regularly, especially after major updates. It provides a simple but effective way of confirming that answers users already trust continue to behave as expected, even as the platform grows and changes around them.

Step 3: Teach Genie How Your Business Thinks

Metadata is what helps bridge the gap in business thinking in natural flow and tables, columns, or schemas. The richer the business context around your data, the easier it becomes for Genie to understand what the user is really asking and translate that intent into a query that makes sense. In many cases, improving metadata delivers a bigger uplift in answer quality than yet another round of prompt tuning.

Table Descriptions Matter

Avoid generic descriptions like:

Customer transaction table

Instead use:

Contains finalized customer purchase records used for revenue reporting and financial performance analysis.

The second description provides significantly more business context.

Define Synonyms Explicitly

Business users rarely use technical column names.

For example:

Business Term Actual Field

Sales	Revenue
ARR	Annual Recurring Revenue
Customer Base	Active Customers
Gross Sales	Invoice Amount

Providing synonyms dramatically improves question interpretation.

Document Relationships

Another area that often gets overlooked is the way datasets relate to one another. In most enterprises, the same business entity appears across multiple tables, and there can be several possible paths between them. If those relationships aren't clearly defined, Genie may have to infer how the data is connected, which can lead to unexpected results.

Explicitly documenting relationships and validating the business meaning behind them significantly improves consistency. It's not enough to know that two tables can be joined; Genie also needs to understand how they should be joined and what business context that relationship represents.

Incorrect joins are a major source of AI-generated analytical errors.

Supply Example SQL

One of the most effective yet underutilized techniques is maintaining a library of gold-standard SQL.

Example:

SELECT fiscal_year, SUM(revenue) AS total_revenue FROM sales_gold GROUP BY fiscal_year ORDER BY fiscal_year;

These examples act as patterns that help Genie generate more reliable queries.

Use General Instructions Sparingly

Many teams attempt to solve every issue through lengthy instructions.

This typically creates maintenance problems.

A simpler decision framework is:

Problem Fix Location

Wrong table	Table metadata
Wrong column	Column description
Wrong value mapping	Example values
Wrong join	Relationship definition
Wrong calculation	Example SQL

Use narrative instructions only for business context.

Key Takeaways

Organizations often assume conversational analytics starts with AI.

In reality, it starts with data engineering.

Before focusing on prompts, invest in:

Curated Gold datasets
Metric definitions
Rich metadata
Relationship modeling
Benchmark testing

Genie Spaces are most successful when they are grounded in governed business semantics rather than isolated prompt instructions. Databricks' broader investment in Unity Catalog Semantics reflects this exact direction, creating trusted business context that can be reused across analytics and AI experiences.

2-Part Series

Part 1: Making Databricks Genie Spaces Actually Work: A Practical Framework for Client and Data Teams
Part 2: Operationalizing a Live Genie Spaces with Benchmarking, Governance, and Continuous Improvement

CUSTOMER STORY | Kraken governs utility data at scale with Unity Catalog

Tushar_Parekar — Tue, 01 Sep 2026 17:04:24 GMT

"Unity Catalog allows us to deliver data in the safest and most compliant way for our customers. Given the liability involved, that is not something we take lightly." - Javi Asensio, Head of Data and Analytics Engineering, Kraken

Kraken, the operating system for utilities, supports approximately 85 million contracted accounts across 13 countries. With Unity Catalog and Delta Sharing, Kraken is building a governed data foundation that helps utility providers access data securely, while giving internal teams better visibility across a complex, multi-account environment.

Key highlights:

95% of governance needs met natively: System tables and the Unity Catalog API provide visibility into access, queries, endpoints, and resource usage without relying on third-party tooling.
Data sharing in 1 day instead of 1.5 weeks: Delta Sharing helps Kraken make data available to clients faster, especially for customers already using Databricks.
Secure, fine-grained access: Account isolation, data masking, and role-based controls help protect sensitive personal, financial, and smart-meter data across regulated markets.
One governance layer at scale: Unity Catalog helps Kraken manage access, auditability, and compliance across dedicated Databricks environments for each client.

🔗 Check out the full story 👈

Webassesor last name change

Ds_1_0 — Tue, 01 Sep 2026 17:00:12 GMT

Hi, anyone knows how to contact databricks support? Or how long it takes to get any response from them?

I need to change my last name in webassesor, can't do this my self.

Already had to move my exam 4 times becasue support is not responsive. I've tried both... an email and the form..

Como aprender correctamente en el entorno de DataBricks y aprovecharlo al 100%

maycol25 — Tue, 01 Sep 2026 16:59:48 GMT

Hola a todos, soy ingeneriero en sistemas y deseo aprender a utilizar esta grandiosa herramienta para poder sacarle el mejor provecho posible.

Re: Building Agentic Applications on Databricks - file not found for ./Includes/Classroom-Setup-2

Satyasai — Tue, 01 Sep 2026 15:52:57 GMT

I hope you have not cloned course repository

to clone use this url

https://github.com/databricks-academy/building-agentic-applications-on-databricks

Re: Congratulations Databricks Partners! You're Now Officially Recognized in the Databricks Communit

kk21 — Tue, 01 Sep 2026 15:02:52 GMT

https://www.linkedin.com/feed/update/urn:li:share:7500568406555873281/

DATA + AI World Tour 2026

Tushar_Parekar — Tue, 01 Sep 2026 14:50:13 GMT

🔥 REGISTRATION IS NOW OPEN

The Data + AI World Tour is heading your way 🌐

A free, one-day event on how organizations are building AI they can trust to deliver real outcomes - by grounding models in their own enterprise data and business context.

THE TOUR BY THE NUMBERS

CITIES

40,000+

ATTENDEES

800

Who pays cross-cloud egress for Delta Sharing from GCP to Azure?

mariajsm — Tue, 01 Sep 2026 14:47:04 GMT

Hi DBX community!! Are cross-cloud egress charges for a Databricks-to-Databricks #DeltaShare billed to the provider account, and do they apply when the shared objects are views backed by Cloudflare?

I'm setting up a Delta Share using Databricks on GCP (us-central1) as the provider. The shared objects are views in Unity Catalog, and the underlying data is stored in Cloudflare R2.

The recipient is a customer using Databricks on Azure (West region). I'd like to understand how the costs are handled in this scenario:

Is there a cross-cloud egress/network charge when the Azure recipient queries the shared views?
If so, is that egress charge billed to the provider (GCP) or the recipient (Azure)?
Since the underlying data is stored in Cloudflare R2, does R2's lack of egress fees change or eliminate any of the Databricks cross-cloud egress charges?
Are there additional Databricks compute charges on the provider side when the recipient queries views through Delta Sharing?
Is there a recommended architecture to minimize costs if the recipient will query the shared data frequently?

Any clarification or real-world examples of how these charges appear in billing would be greatly appreciated.

Re: Certification Not Issued

Psangi — Tue, 01 Sep 2026 14:09:10 GMT

I have already raised two support cases after checking my spam folder and I'm only here because of no response from Databricks support. Below are the two support tickets raised for the same.

I understand that your team may not provide support through community but what should a person do in spite of following up since last 10 days with tickets not even being acknowledged. I almost spent 3-5 hours on this single matter and you can imaging how frustrating it would be for an individual.

(00998141 and 01000010)

Custom Visualizations in Databricks AI/BI Dashboards: Build a Dumbbell Chart

pstyld — Tue, 01 Sep 2026 14:01:18 GMT

Need a visualization your standard AI/BI dashboard widgets can't create? Databricks AI/BI custom visualizations let you use Vega-Lite to build highly tailored charts. Learn how to craft a dynamic dumbbell chart with automated sorting, dynamic labels, tooltips and Genie-assisted code enhancements.