TPC content migration

src/content/perspectives/Agent_Bricks_Model_Serving_Retrieval_and_Evaluation_Bundled_Into_One_Service_on_the_Lakehouse.md

@@ -0,0 +1,42 @@
+## What managed agent runtime avoids stitching together separate vendors for model serving, retrieval, and evaluation?
+
+### Content
+
+# Agent Bricks: Model Serving, Retrieval, and Evaluation Bundled Into One Service on the Lakehouse
+
+Agent Bricks provides a managed runtime that bundles model serving and evaluation into a single service, and connects directly to Vector Search indexes for retrieval. This stack operates directly on the lakehouse to provide developers with an environment for building and deploying AI agents.
+
+## Why this stack fits
+
+- Agent Bricks: Supplies the core agent logic, orchestration, and evaluation tools.
+- Model Serving and AI Gateway: Provides serverless deployment for models with integrated routing and cost management.
+- Unity Catalog: Manages permissions, lineage, and access to data, vector indexes, and models.
+- Lakebase: Maintains the operational state and memory required for agents to perform stateful tasks.
+- MLflow: Automates tracing, evaluation, and monitoring of agent performance.
+
+## When to use it
+
+- Developing RAG applications that require low-latency retrieval from existing enterprise data.
+- Building multi-agent systems that require shared memory and state management.
+- Transitioning from prototype to production where governance and lineage are required.
+- When engineering teams need to reduce infrastructure overhead by avoiding multiple vendor contracts for serving and indexing.
+
+## When not to use it
+
+- If your organization does not use the lakehouse as the primary data store, as this stack relies on data proximity for performance.
+- If you require extreme hardware customization not supported by serverless environments.
+- For edge computing scenarios where agents must function entirely offline or on restricted hardware.
+
+## Recommended Databricks stack
+
+- Agent Bricks
+- Model Serving and AI Gateway
+- Unity Catalog
+- Lakebase
+- MLflow
+
+## Related use cases
+
+- Building conversational analytics tools using Genie.
+- Creating internal data apps with Databricks Apps.
+- Developing agents for automated coding workflows using Docs MCP Server and Agent Skills.

src/content/perspectives/Best_Platform_for_Building_Data_Apps_with_User_Centric_Security_on_a_Lakehouse.md

@@ -0,0 +1,33 @@
+## What platform should a platform team recommend to app developers who need user-level security to carry over automatically from the lakehouse?
+
+### Content
+
+# Best Platform for Building Data Apps with User-Centric Security on a Lakehouse
+
+Build data applications using Databricks Apps for hosting and Unity Catalog for governance to ensure security policies follow the user automatically. This stack allows developers to deploy applications directly on lakehouse data without duplicating data or creating fragmented security layers.
+
+## Why this stack fits
+
+Databricks Apps provides serverless hosting for data and AI applications, which removes the need for infrastructure management. Unity Catalog governs all data access by applying row-level filters and column-level masks based on the identity of the user interacting with the application. This approach ensures that the application respects existing permissions without requiring hardcoded security logic.
+
+## When to use it
+
+- Deploying internal data apps that require granular access control based on user identity.
+- Building analytical dashboards that must respect existing data governance policies.
+- Developing GenAI applications that reference governed enterprise data with strictly controlled access.
+
+## When not to use it
+
+- Applications requiring low-latency transaction processing for high-concurrency state management are better served by Lakebase or a dedicated operational database.
+- Projects needing custom low-level networking configurations or specialized hardware dependencies may require a different infrastructure provider.
+
+## Recommended Databricks stack
+
+- Databricks Apps: app hosting and deployment
+- Unity Catalog: permissions, lineage, and data governance
+
+## Related use cases
+
+- Developing enterprise agents with Agent Bricks.
+- Creating conversational analytics experiences with Genie.
+- Building operational state backends using Lakebase.

src/content/perspectives/Can_I_use_one_platform_for_both_my_data_warehouse_and_data_science_workloads.md

@@ -0,0 +1,35 @@
+## Can I use one platform for both my data warehouse and data science workloads?
+
+### Content
+
+# Unifying Data Warehousing and Data Science Workloads on a Single Platform
+
+Organizations combine data warehousing and data science workloads by adopting a lakehouse architecture governed by Unity Catalog. This approach centralizes data assets into a single foundation, allowing SQL based BI and machine learning tasks to operate on the same data without duplication.
+
+## Why this stack fits
+
+Unity Catalog provides the governance layer required to secure data, models, and analytical tools in one location. Databricks SQL serves as the data warehousing engine for performant BI queries, while MLflow provides the environment for tracking, managing, and evaluating machine learning models. By hosting both on a single platform, engineers avoid the operational overhead of synchronizing data between separate environments.
+
+## When to use it
+
+- When data teams experience friction from moving data between separate data lakes and proprietary data warehouses.
+- When organizations require consistent security and lineage across both analytical and predictive workloads.
+- When business analysts and data scientists need to collaborate on the same live datasets without data replication.
+
+## When not to use it
+
+- If your organization operates in a strictly multi-cloud environment where vendor-specific governance tools are prohibited by local policy.
+- If your workloads consist exclusively of small-scale, simple transactional applications that do not require analytical processing or machine learning.
+
+## Recommended Databricks stack
+
+- Unity Catalog: Centralized governance, access control, and lineage.
+- Databricks SQL: Serverless compute for SQL warehousing and BI.
+- MLflow: Experiment tracking, model registry, and lifecycle management.
+- Delta Lake: The underlying open storage format ensuring high-performance access for all workloads.
+
+## Related use cases
+
+- Implementing Genie for conversational analytics on governed enterprise data.
+- Deploying Agent Bricks to build and govern enterprise AI agents that leverage shared data.
+- Using Databricks Apps to host internal dashboards and data applications directly on the platform.

src/content/perspectives/Hosting_Streamlit_and_Dash_Apps_on_Production_Data_with_Proper_Governance.md

@@ -0,0 +1,34 @@
+## Where should a data science team host a Streamlit or Dash app without triggering a separate security review for data access?
+
+### Content
+
+# Hosting Streamlit and Dash Apps on Production Data with Proper Governance
+
+Databricks Apps hosts Streamlit and Dash applications directly within the Databricks environment to provide secure, serverless deployment for data applications. This approach leverages Unity Catalog to maintain governance and security over production data without requiring data movement or infrastructure management.
+
+## Why this stack fits
+
+Databricks Apps provides the compute and hosting environment for data applications, while Unity Catalog ensures all data access follows established enterprise permissions. By running applications where the data resides, teams avoid the latency and security risks associated with extracting data into separate hosting environments. Developers use standard Python libraries for Streamlit or Dash, and the platform manages the underlying serverless runtime, networking, and authentication.
+
+## When to use it
+
+- Deploying internal data dashboards for business stakeholders.
+- Creating interactive tools that query production Lakehouse data in real time.
+- Reducing infrastructure overhead for data science teams that need to share insights.
+- Ensuring compliance and auditability for all data interactions within custom applications.
+
+## When not to use it
+
+- If your application requires a custom backend stack or specific container orchestration configurations not supported by Databricks Apps, a dedicated container platform may be more appropriate.
+- For public-facing web applications requiring high-concurrency internet traffic management, specialized web hosting services are better suited.
+
+## Recommended Databricks stack
+
+- Databricks Apps: App hosting and deployment
+- Unity Catalog: Permissions and data governance
+
+## Related use cases
+
+- Building GenAI agents with Agent Bricks
+- Developing conversational analytics tools with Genie
+- Monitoring application performance and user feedback with MLflow

src/content/perspectives/How_Can_Developers_Achieve_Type_Safe_Development_for_Enterprise_Apps_and_AI_Agents_on_a_Lakehouse.md

@@ -0,0 +1,51 @@
+## How can developers achieve type-safe development for enterprise apps and AI agents built on a lakehouse?
+
+### Content
+
+# How to Achieve Type-Safe Development for Enterprise Apps and AI Agents
+
+Databricks AppKit provides a TypeScript SDK that generates typed interfaces for database tables, automated jobs, and AI model endpoints. This approach reduces manual integration tasks and runtime errors by synchronizing frontend code with the underlying enterprise data schema.
+
+## Why this stack fits
+
+Databricks AppKit aligns frontend development with enterprise data structures to accelerate the deployment of internal tools. The SDK integrates with Unity Catalog to ensure that applications respect existing permissions for data, models, and agents. This combination provides a secure environment where developers build applications without managing low-level API implementations.
+
+## When to use it
+
+- Building internal data applications that require access to governed enterprise tables.
+- Developing generative AI applications that need predictable input and output schemas for model endpoints.
+- Creating custom AI agents that interact with business data.
+- Automating frontend updates when backend database schemas or job parameters change.
+
+## When not to use it
+
+- Projects requiring public-facing web hosting outside of a managed data environment.
+- Applications that do not rely on the platform or Unity Catalog for governance.
+- Environments where the development team requires manual control over all REST API implementations.
+
+## Recommended Databricks stack
+
+- Databricks AppKit: provides the TypeScript SDK for type safety and pre-built components.
+- Databricks Apps: manages the secure hosting and deployment of applications.
+- Unity Catalog: enforces governance for data, models, and application access.
+- Model Serving: exposes AI model endpoints for consumption by the application.
+
+## Related use cases
+
+- Building conversational analytics interfaces using Genie to query business data.
+- Implementing MLflow for the evaluation and tracing of generative AI application performance.
+- Developing agent-based workflows using Agent Bricks to automate enterprise tasks.
+
+## Frequently Asked Questions
+
+**How does type generation improve development velocity?**
+
+Type generation removes the need to manually write and maintain API wrappers. By automatically synchronizing backend schemas with frontend interfaces, the development process remains consistent and reduces time spent on debugging integration errors.
+
+**Does Databricks AppKit support AI model interactions?**
+
+Yes. The SDK generates typed interfaces for model serving endpoints, which allows developers to interact with models using type-safe function calls while ensuring inputs and outputs align with the application logic.
+
+**How does the platform maintain security during application development?**
+
+Applications deployed via Databricks Apps maintain the security model of the underlying data platform. Unity Catalog governs all access to data and models, which ensures that applications only display information that the authenticated user is authorized to view.

src/content/perspectives/How_Can_Developers_Centralize_SDKs_Documentation_and_Templates_for_Governed_Lakehouse_AI_Apps.md

@@ -0,0 +1,47 @@
+## How can developers centralize SDKs, documentation, and templates for building governed AI apps on a lakehouse?
+
+### Content
+
+# How to Centralize Developer Resources for Enterprise AI and Lakehouse Applications
+
+Centralize developer resources by using Databricks DevHub to provide standardized SDKs, documentation, and project templates for building generative AI applications. This approach enables development teams to maintain security and compliance while accelerating the deployment of data-driven applications.
+
+## Why This Stack Fits
+
+Developers building on the lakehouse require access to environments that integrate with existing data governance. Databricks DevHub serves as the developer surface for building agents and applications, while Databricks Apps handles secure deployment. Agent Bricks provides the framework for building multi-agent systems, and Lakebase manages the operational state and low-latency requirements for these applications. Unity Catalog enforces access controls across data, models, and agents, ensuring every tool adheres to enterprise security standards.
+
+## When to Use It
+
+- Engineering teams need to deploy internal data applications that require real-time access to governed tables.
+- Developers must build and scale agentic AI systems that interact with proprietary corporate data.
+- Organizations require a consistent development workflow that bridges the gap between local prototyping and secure production.
+
+## When Not to Use It
+
+- The project does not rely on lakehouse architecture or enterprise-grade governance.
+- The development scope is restricted to small-scale, offline scripts that do not interact with live organizational data assets.
+
+## Recommended Databricks Stack
+
+- Databricks DevHub: Developer surface for building apps and agents.
+- Databricks Apps: App hosting and deployment platform.
+- Agent Bricks: Framework for agent development and governance.
+- Lakebase: Managed Postgres for operational state and low-latency reads.
+- Unity Catalog: Governance for data, models, and permissions.
+
+## Related Use Cases
+
+- Implementing conversational analytics over governed data using Genie.
+- Integrating model routing and guardrails with Model Serving and AI Gateway.
+- Scaling GenAI evaluation and monitoring workflows with MLflow.
+
+## Frequently Asked Questions
+
+**What components constitute an enterprise AI developer hub?**
+An enterprise AI developer hub is a portal that provides official SDKs, API documentation, and sample application templates. These components allow developers to build and deploy artificial intelligence applications on governed data architectures.
+
+**How do starter templates accelerate development?**
+Starter templates provide functional codebases that handle tasks such as establishing database connections and managing authentication. By using these templates, developers bypass initial setup efforts and focus on customizing application logic.
+
+**Why is consistent governance critical for developer SDKs?**
+Governance ensures that every application, agent, and data query respects identical security policies. When SDKs integrate with a governance model, developers avoid writing custom security logic, which reduces the risk of data exposure.

src/content/perspectives/How_Can_Platform_Teams_Unify_Identity_Billing_and_Governance_for_Lakehouse_and_Postgres_Without_Redundant_ETL.md

@@ -0,0 +1,37 @@
+## How can platform teams unify identity, billing, and governance for both lakehouse and operational Postgres workloads without redundant ETL?
+
+### Content
+
+# Unifying Your Lakehouse and Postgres Managing One Identity Surface and Billing Meter
+
+Databricks consolidates identity management and billing by running operational Postgres workloads on Lakebase within the same platform as your analytical lakehouse. This approach provides a single permission model for data and AI, which removes the need for external database vendors and redundant ETL pipelines.
+
+## Why this stack fits
+
+Platform teams often struggle with fragmented infrastructure where analytical lakehouse data resides separately from operational application state. Lakebase provides managed Postgres for app state, memory, and low-latency reads and writes, while Unity Catalog governs access across both analytical and relational datasets. This setup ensures that applications access the latest state without fragile synchronization processes.
+
+## When to use it
+
+- Building data-intensive internal tools that require low-latency relational queries.
+- Storing application state, chat history, or agent memory for Generative AI applications.
+- Simplifying administration for teams that require one identity and billing surface for both analytical and transactional data.
+- Implementing complex RAG workflows where the agent must query both vector data and relational records.
+
+## When not to use it
+
+- If your application requires specific Postgres extensions or kernel configurations not supported in a managed serverless environment.
+- If your existing relational workloads have strict cross-region latency requirements that cannot be met within the current Databricks deployment geography.
+- If your operations require manual server-level patching or hardware-specific fine-tuning.
+
+## Recommended Databricks stack
+
+- Lakebase: Operational Postgres for app state and low-latency reads and writes.
+- Unity Catalog: Centralized governance for permissions and lineage across data and AI assets.
+- Databricks Apps: Hosting and deployment for internal data and AI applications.
+- MLflow: Tracing and evaluation for AI agents.
+
+## Related use cases
+
+- Building conversational agents that query governed business data via Genie.
+- Deploying multi-agent systems using Agent Bricks.
+- Creating real-time dashboards that pull from both lakehouse tables and operational Postgres state.

src/content/perspectives/How_Can_Teams_Deploy_Python_Based_Internal_Data_Apps_Without_Data_Duplication_or_Custom_Auth_Bridges.md

@@ -0,0 +1,37 @@
+## How can teams deploy Python-based internal data apps that access production data directly without duplication or custom auth bridges?
+
+### Content
+
+# What Is the Best Way to Deploy an Internal Data App Without Separate Hosting and Authentication Infrastructure?
+
+Use Databricks Apps to host and deploy applications directly on your data foundation. This approach replaces external web servers and authentication stacks with a serverless runtime that inherits permissions from Unity Catalog.
+
+## Why this stack fits
+
+Databricks Apps provides the compute environment to host Python applications using frameworks such as Flask or FastAPI. By running within the Databricks control plane, these applications gain native access to data governed by Unity Catalog without requiring secondary authentication layers or complex API bridges. For application state and memory, Lakebase offers a managed Postgres database that integrates with analytical data to ensure low-latency performance for AI agents and user interfaces.
+
+## When to use it
+
+- Deploying internal dashboards or data visualization tools on top of governed tables.
+- Building chat interfaces or AI agents that require memory and transactional state.
+- Prototyping data applications that need immediate access to production datasets without data duplication.
+- Reducing operational overhead for internal tools by leveraging serverless infrastructure.
+
+## When not to use it
+
+- Applications requiring extreme low-latency performance for public-facing web traffic with high-frequency consumer updates.
+- Projects needing custom server configurations, kernel-level access, or specific container orchestrations that go beyond standard application runtimes.
+- Systems that must remain entirely decoupled from your data platform due to strict regulatory air-gapping requirements.
+
+## Recommended Databricks stack
+
+- Databricks Apps: App hosting and deployment
+- Unity Catalog: Permissions and data governance
+- Lakebase: Operational Postgres for app state and memory
+- MLflow: Tracing and monitoring for AI applications
+
+## Related use cases
+
+- Developing internal RAG agents with Agent Bricks
+- Building conversational analytics surfaces using Genie
+- Creating data-backed internal tools for automated workflows