Databricks Apps

Build with Replit Against Managed Postgres in Databricks Apps

Dark mode setting ignored when embedding BI dashboard inside Databricks App

Databricks Apps - Deployment process - Need help !!

Did anyone get an hands on Databricks apps

Hoping a discussion and insights from an individual who had an hands on databricks apps submitted by /u/BugSquare4344 [link] [comments]

Databricks Apps / AppKit

Hi, what do u use for creating user facing apps, we are primary using Python, i see that Databricks recommends AppKit for such use cases which is written in TS. For teams which deploys apps that are customer facing, what is your stack? submitted by /u/ptab0211 [link] [comments]

Open Sharing protocol of Databricks Apps and SaaS sharing

I want to understand the open sharing protocol, how it is sharing the apps, what artefact is shared when app is shared, is it sharing the app files from Workspace path directly? Secondly, how the SaaS is shared and what artefact is shared and how? Could not find documentation. Thanks

Databricks Apps - "App Not Available" error with locationId parameter missing

Databricks Apps (Streamlit) - How to Implement Proper Logout Functionality?

Databricks Marketplace: IP Protection, Job Compute, and Secret Management

I am planning to publish an application through Databricks Marketplace. The application contains proprietary business logic and processing algorithms that must not be accessible to customers after installation. Customers should be able to use the application to process data in their own Databricks environment, but they should not be able to inspect, copy, or reuse the underlying implementation. Approaches I Have Tried I have considered the following approaches: Packaging the implementation as Python wheels or other artifacts. Hosting the implementation as private Python packages. Deploying the application source from a private Git repository. With the packaging approach, the underlying Python implementation may still be accessible or inspectable from notebooks, workspace files, cluster environments, package caches, or other customer-accessible locations. This does not meet my IP-protection requirements. With private package hosting, the package installation requires an access token or API key. Providing a reusable package-registry credential to an application running in the customer's workspace creates a risk that the credential could be extracted or reused to download the private package outside the intended application flow. I also understand that Databricks Marketplace reviewers may require the submitted application code to be human-readable during the review process. Therefore, I am looking for an architecture that protects the production implementation without relying only on code obfuscation. Current Understanding My understanding is that a Databricks App runs in an isolated, containerized runtime. This provides separation between the application runtime and normal customer workspace resources. However, my workload includes processing large datasets. I understand that Databricks App compute is primarily intended to run the application, API, or user interface, rather than perform large-scale Spark processing. Because of this, I am unsure whether Databricks App […truncated]

Databricks apps versus ServiceNow apps

Automatic Git Deployments for Databricks Apps from Github

Cut our Databricks Apps costs by 76% with two scheduled jobs (start/stop)

Databricks apps

How to create Databricks Jobs Monitoring in your custom Databricks App

Databricks Jobs Monitoring in Your Custom Databricks App

We replaced Streamlit with a Python UI compiler we built now deploying on Databricks Apps in hours

Databricks Apps vs Power Apps -/ which to use when you need a UI for business rules? (cost-sensitive)

Hi everyone, I’m deciding between Databricks Apps and Microsoft Power Apps for a simple but important need and I’d love your experience/advice. Context: • I have models and data processing in Databricks (already built a demo + deployment using Databricks). • Need a small UI so business users can edit/add rules (stored in a table) that our models use. • I care a lot about cost. I don’t have an easy way right now to start/stop Databricks compute to save money. • I already run regression tests and understand Databricks workflows, but I don’t fully know the real benefits of Databricks Apps vs Power Apps for this use case. Questions: 1. For a rules-editing UI (CRUD for a rules table) what worked better for you: Databricks Apps or Power Apps? 2. Cost-wise, which is cheaper to build/run for low-traffic business users? 3. Any recommended patterns to connect a low-code UI (Power Apps) to Databricks compute securely and cheaply? 4. If you chose Databricks Apps, how do you reduce runtime cost — do you use job clusters, serverless endpoints, or something else? I have this decision tree (WIP).

OAuth authentication is required for MCP servers hosted on Databricks Apps

Genie code or AI Dev kit?

Hey everyone — I’m planning to build a quick demo using Agent Bricks with a lightweight frontend through Databricks Apps. For development, would you recommend using Genie Code or AI Dev Kit? Curious which one people have found better for rapidly building and iterating on Databricks-native AI applications.

Since joining Databricks, I've stopped running init commands for new web apps

Ever since joining Databricks, I've stopped running init commands manually when starting new web app projects. If you're a web developer, starting a new app usually starts with running an "init" command in your CLI. For example, if you were using Next.js, you would run: >`npx create-next-app@latest my-app --yes` `cd my-app` `npm run dev` Building apps on Databricks with [AppKit](https://github.com/databricks/appkit) is similar: >`databricks apps init --name my-app` `cd my-app` `npm run dev` As a developer, that workflow is pretty much muscle memory: * run the init command * `cd` into the project * start the dev server But lately I've been doing something different since it is [recommended by the AppKit docs](https://www.databricks.com/devhub/docs/appkit/v0/#quick-start-options) to just prompt your AI assistant instead. So now, what I do is: >`mkdir my-app` `cd my-app` `cursor .` (or sub with your favorite coding agent) Once Cursor is open, I type: >"Create a new Databricks app in this folder and start the dev server" The agent scaffolds the app using the same init command behind the scenes and starts everything for me. Honestly, doing it this way feels super weird...after years of manually running setup commands, this takes a lot to get used to 😅 But the more I do this, the more I see the benefits. Firstly, I no longer need to remember what the init command is, or look up what CLI flags it accepts. Secondly, this pattern is framework-agnostic. I no longer need to remember framework-specific setup commands or look up docs. The same prompt pattern works across frameworks: * "Create a new Next.js app..." * "Create a new Nuxt app..." * "Create a new SvelteKit app..." * "Create a new TanStack Start app..." * "Create a new Databricks app..." You get the picture... Same intent. Different tooling. Thirdly, and most importantly, **I can infinitely expand the prompt**. I can easily add any additional instructions to the end of my prompt for the agent to follow. For example, I can say: >"Create a new Databricks app in this folder and start the dev server **and commit everything to git and deploy my app**" This will not only create my app, but also create a git repo and deploy the app without me needing to remember specific commands or look up any docs! I'm curious, have you also started shifting your workflow this way, or are you still mostly scaffolding projects manually? \--- One important note, the reason the agent can reliably handle prompts like: "Create a new Databricks app in this folder and start the dev server" ...is because of [agent skills](https://agentskills.io/home). Specifically, if you're building Databricks apps, you should check out and install [databricks-agent-skills](https://github.com/databricks/databricks-agent-skills). Without the proper skills/context, the agent may not know the correct setup flow or commands to use.

Managing Unity Catalog Permissions for Databricks Apps via DABs

New to Databricks DevRel - what do you want to learn about Apps + Lakebase?

Hello r/databricks! Tony here 👋 Long-time web developer, first-time poster in this subreddit 🙂 I recently joined the DevRel team at Databricks, where I’ll be focused on helping developers build with Databricks Apps + Lakebase. My background is in webdev, and I’ve always cared a lot about developer experience. I love tools like vite / hono / playwright, because they have super fast feedback loops, are simple to use, have great docs, etc. One thing that excited me about joining Databricks is the opportunity to make building on the platform feel more approachable for developers coming from more traditional app/web backgrounds (like me). I’m still very new to the Databricks ecosystem (less than a month in!!), so I’m still in full “learn everything” mode. As I ramp up, I’m hoping to work in public a bit and share what I learn along the way. So, I’d love to hear from this community: * What would you want to learn about Databricks Apps or Lakebase? * What do you wish was easier when building apps on Databricks? * What parts of the DX feel rough or confusing? * Are there example projects, integrations, or tutorials you wish existed? <- I’d love to help by creating some content if it’s useful. Just lmk! Looking forward to learning from everyone and being part of the community!

Free Modular Project Structure for Databricks Apps with Streamlit

Modular structure for Databricks Apps (Streamlit)

Hey, I wanted to share something that's been bugging me for a while and get your take. The official Databricks Streamlit tutorial puts everything into a single **app.py.** Fine for a demo. But the moment a real internal app grows past \~500–600 lines, it stops being fun: * Two people on the team touch the same file → merge conflicts every PR. * Hard to write unit tests when UI, data access, and business logic live in one module. * Git diffs become unreadable, and code review suffers. * When I point Cursor/Claude at the repo, it has to re-read the whole monolith on every prompt. Context window and cost both balloon. So I refactored our internal template into something more boring and modular: app. py # entry point only, routing pages/ ├── home. py ├── analytics. py └── settings. py components/ # reusable UI bits services/ # SQL warehouse / UC / SDK calls assets/ ├── styles.css └── logo.png tests/ *This is my own repo, not a product. Sharing because the single-file pattern bit us hard, and I figured others might find it useful -* [*https://github.com/protmaks/databricks\_apps\_streamlit\_mod\_template*](https://github.com/protmaks/databricks_apps_streamlit_mod_template)

SCIM scope Databricks Apps

Was creating a utility app to add new users into workspace via a frontend. Using the forwarded access token for the sdk users.create method, I am trying to add a user. However getting exception for scim scope. How do I solve this?

Genie improvements for April 2026

* **Weekly digest and monitoring**: The **Monitoring** tab includes a **Weekly digest** section showing weekly messages, users, and thumbs up/down feedback. Authors can also use Genie Code to summarize top usage trends and common issues from the monitoring page. * **PDF file uploads**: Upload PDF files directly into a Genie Space to analyze their content using natural language. 📖 [Documentation](https://docs.databricks.com/aws/en/genie/file-upload) * **Databricks Apps search**: You can search for Databricks Apps from the Genie search bar. * **Reasoning traces using the API**: Users can access Genie’s reasoning traces using the API through the `GenieQueryAttachments` field in the `GenieMessage` object. 📖 [Documentation](https://docs.databricks.com/api/workspace/genie/getmessage) * **Message comments using the API** : Users can add text comments to messages and list them using the API. 📖 [Documentation](https://docs.databricks.com/api/workspace/genie/createmessagecomment) * **Increased token limit for Agent mode**: The maximum token limit for Agent mode conversations increased, improving performance and context retention across long, multi-turn interactions. * **Embed a Genie Space**: You can embed a Genie Space as an iframe in a website or application. 📖 [Documentation](https://docs.databricks.com/aws/en/genie/embed) * **Space thumbnails**: Genie Space authors can attach thumbnails to a space. Thumbnails appear on the Genie Space’s initial chat page and in Genie.📖 [Documentation](https://docs.databricks.com/aws/en/genie/set-up#config) * **Request Review for Agent mode**: Users can request a review for Agent mode messages. * **Table visualizations with conditional formatting**: Genie can generate table visualizations with conditional formatting colors for better readability. * **Agent mode as default**: Agent mode is the default conversation setting in Genie Spaces. * **Account-level Genie is GA**: Account-level Genie includes Databricks Apps, Domains, and Genie. 📖 [Documentation](https://docs.databricks.com/aws/en/workspace/genie-account) * **Updated workspace Genie navigation**: The workspace Genie left-hand navigation has been updated and includes Genie Code chat history. * **Column display names**: Space authors can set user-friendly display names on table and view columns. Display names appear in query results and in downloaded CSVs. * **Genie Conversation API is GA**: Use the API to programmatically start conversations, send questions, and retrieve results from Genie Spaces. 📖 [Documentation](https://docs.databricks.com/aws/en/genie/conversation-api) * **Agent mode workspace themes**: Visualizations in Genie Agent mode use workspace-level themes. * **Agent mode prompt caching**: Genie Agent mode now caches repeated prompts, reducing response latency. * **Navigation between Genie surfaces**: Users can navigate between Account Genie and workspace Genie.

Databricks Apps Tutorial: Scalable Streamlit Modular Template for Production

Three MCPs, One Answer: Building a Data Quality Monitor on Databricks Apps

Deploying Django apps on Databricks Apps with Lakebase

Using a separate Databricks App as a backend? Anyone doing this in practice?

I’m working on an internal operational app and trying to figure out the “right” architecture within Databricks. The use case is pretty straightforward: \- Generate recommendations in Databricks (served via Lakebase) \- Combine that with live operational data (APIs) \- Display everything in a Databricks App What I’m debating is where the composition/orchestration layer should live. One idea I’m exploring: Databricks App #1 → user-facing UI Databricks App #2 → acts like a lightweight backend (aggregates recommendation + live data) Basically treating a Databricks App as a dedicated backend layer. I don’t see this pattern mentioned much in the Databricks Apps Cookbook or docs, which seem to lean toward: single app direct access to data + endpoints So I’m curious: Has anyone actually used a separate Databricks App as a backend/service layer? Did it hold up in terms of latency / maintainability? Any gotchas with auth, scaling, or observability? Or is this one of those “it works but you shouldn’t” patterns? For context, this is internal, medium usage (\~10–20 concurrent users), not internet-scale.

New Databricks Apps: What About Cost at Scale?

I’ve been looking into the new Databricks Apps compute model, and I have one concern.From what I understand, each Databricks App now runs with its own dedicated app compute, rather than simply relying on a shared SQL Warehouse as the main execution layer. I’m wondering what this means at scale. If an organization has dozens or even hundreds of small internal apps, could this become significantly more expensive if each app requires its own compute instead of how it was before all of them sharing a single SQL serverless cluster that can scale to 0? I’d be interested to hear how others are approaching this: Are you consolidating multiple use cases into fewer apps, stopping unused apps, or using another pattern to control costs?

Governance in Databricks Apps

I built an app using Streamlit and it's running on Databricks Apps. The app has modules that query catalogs, sending the user's token to use Databricks governance. However, my managers didn't like that the user could execute queries within Databricks. I could use the service principal in the catalog permissions instead of authorizing the user, but I would have to create an ACL system within the app, which could make it complex. Have you built something similar and could offer some ideas?

I built a free 11-tab Cost Observability Dashboard as a Databricks App — open source