Featured Issues

Mobile development blogs, tutorials and resources inside!Latest Mobile Dev Insights: iOS, Android, Cross-PlatformAdvertise with Us|Sign Up to the NewsletterMobilePro #226: When iOS Understands the ConversationHi ,The best AI feature might be the one your users never notice.The AI conversation often revolves around bigger models, better prompts, and smarter assistants. But increasingly, the most useful experiences come from intelligence that's quietly woven into the platform itself. Instead of asking users to interact with AI directly, the operating system simply understands enough context to make the next step easier.That's exactly what this week's article explores with iOS 27's new Suggested Actions framework. By turning conversations into context-aware system actions, like creating calendar events or opening locations, Apple is showing a different direction for AI in mobile apps. It comes at an interesting time, with iOS 26.6 preparing developers for the transition to iOS 27, Claude Code bringing live iOS Simulator testing into the development workflow, and Android moving toward a more open AI ecosystem. The future of mobile development isn't just about adding AI—it's about knowing when the platform can do the heavy lifting for you.TL;DRSuggested Actions lets iOS 27 detect useful actions directly from message context.All analysis happens on-device, helping preserve user privacy.Developers provide conversation context while the system decides which actions are relevant.The framework integrates naturally with SwiftUI and can also be embedded into UIKit apps.Stable message identifiers enable action caching for a smoother experience.This approach shifts AI from prompt-driven interactions to intelligent platform capabilities that feel native to users.This week’s news corneriOS 26.6 arrives with security fixes and iOS 27 readiness improvements: Apple has officially released iOS 26.6, delivering bug fixes, security updates, and an optimized Spotlight index to prepare devices for the transition to iOS 27. For iOS developers, this is the recommended build for final compatibility testing on the iOS 26 lifecycle before the platform shifts to iOS 27, making it an important milestone for validating app stability and performance.Claude Code adds live iOS Simulator testing inside Desktop app: Anthropic has introduced an iOS Simulator pane in Claude Code Desktop (public beta), allowing developers to build, launch, inspect, and interact with iOS apps directly alongside their coding session. Claude can observe the live simulator, test UI flows, iterate on code changes, and developers can take over the simulator at any time, making the debugging and validation loop much faster.EU orders Google to open Android AI features and search data to rivals: The European Union has issued new rules requiring Google to open key Android AI capabilities to competing assistants and share portions of its search data with rival search providers. For Android developers, the changes could create a more open ecosystem by enabling third-party AI assistants to integrate more deeply with Android and reducing Google's control over core platform services.A glimpse of BuildWithAI newsletterBuilding with AI is quickly becoming part of every developer's workflow. Each week, Build with AI explores practical AI engineering, agentic development, LLMs, MCP, coding tools, and the techniques shaping modern software development. Here's a glimpse into a recent featured article:10x value, not 10x volume: Where the real gains come fromAs individual developers adopt AI assistants, we frequently hear reports of incredible velocity gains.“Copilot made me 3x faster.”“I built a whole MVP in a weekend that would have normally taken a month.”The Factory era is not a forecast. Large engineering organizations already run in-house agent platforms against their production codebases at a scale no individual could match. That’s the organizational footprint of a practice that has moved well beyond one engineer typing faster.While individual velocity spikes are very real, they often create a localized illusion of productivity that fails to materialize at the organizational level. Individual speed is a false summit. You feel like you have reached the top because your own keyboard is faster, but cycle time and the team’s DORA numbers stay flat until the system around the agent changes. The climb that matters has barely started.Why does the gain vanish? Because of the Theory of Constraints.In any system, improving the throughput of a non-bottleneck step does not improve the throughput of the whole system; it just moves the bottleneck somewhere else. If you make code generation ten times faster, but your code review processes, security audits, QA testing cycles, and deployment pipelines remain manual, you haven’t delivered value to the user ten times faster. You have merely stockpiled a 10x backlog of unverified code waiting to pass through the human bottleneck downstream.This is why the obsession with10x volume, with raw output or hyper-productive individual vibe coders, misses the broader goal. The real gains of the AI transformation do not come from individuals typing faster. They come from10x value: delivered, verified work that reaches the user. And that value comes from designing the team and the system around the agent, not from speeding up the individual at the keyboard.Agentic engineering looks at the entiresoftware development lifecycle(SDLC) holistically. It measures success not by how many lines of code a single individual produces in an hour, but by how dependably the organization ships verified solutions. To track this, agentic teams align closely with the DORA metrics. Originally designed to measure human operational excellence, these metrics become the ultimate lifeline when scaling autonomous agents.Read more...Building Smarter Messaging Apps with Suggested Actions, Not Custom PromptsAnton Gubarenko is an Independent iOS Consultant, Mentor, and Startup Advisor with 16+ years of experience building mobile products. He has worked with companies around the world, from the United States to New Zealand, helping teams design scalable architectures and deliver high-quality iOS applications. Anton continuously follows the latest developments in the Apple ecosystem by exploring Swift and iOS conferences, and shares his knowledge with the global developer community through writing, mentoring, and speaking.Apple added a small framework in iOS 27 that can turn message content into useful actions without requiring a custom language-model prompt.SuggestedActionsView analyzes the message context you provide and displays relevant actions directly below a message. A conversation about watching a movie, for example, can produce an action for adding the agreed cinema time to Calendar.The analysis happens on-device, and the framework does not send the message content to Apple servers.This feature is still in beta and might change before the final release.What Suggested Actions can detectThe framework looks for actionable information inside a conversation. Apple currently highlights examples such as:creating a Calendar event from a proposed timeadding an item to Remindersopening a shared place in MapsYou do not define the buttons yourself. You provide the current message and some previous messages, and the system decides whether an action is appropriate.If no action is available, SuggestedActionsView has zero size and does not add an empty gap to the layout. This means it can safely be added below every message cell.MessageKit or SwiftUI?MessageKit does not provide native SwiftUI message cells. It is a UIKit-based library built around MessagesViewController, MessagesCollectionView, and MessageContentCell.For this example, a small custom SwiftUI chat works better. It also lets us place SuggestedActionsView directly below each message without wrapping it in UIKit.A production UIKit chat can still use the framework by hosting SuggestedActionsView inside a UIHostingController or UIHostingConfiguration.Chat modelThe visual message model contains an optional image, but SuggestedActionsMessage receives the textual message context only:import Foundationimport SwiftUIimport SuggestedActionsstruct ChatMessage: Identifiable { let id: UUID let sender: Participant let text: String let imageName: String? let date: Date struct Participant: Hashable { let name: String let handle: String let isCurrentUser: Bool } var suggestedActionsMessage: SuggestedActionsMessage { SuggestedActionsMessage( id: id, date: date, subject: nil, body: AttributedString(text), sender: .init( name: sender.name, handle: sender.handle, isUser: sender.isCurrentUser ), recipients: [] ) }}The id matters because the framework uses it when caching generated actions.For a real one-to-one conversation, populate recipients with the other participant instead of leaving it empty.Demo conversationThe sample conversation has two friends choosing a movie and agreeing to meet at the cinema:extension ChatMessage { static let anton = Participant( name: "Anton", handle: "anton@example.com", isCurrentUser: true ) static let maya = Participant( name: "Maya", handle: "maya@example.com", isCurrentUser: false ) static let demo: [ChatMessage] = [ ChatMessage( id: UUID(), sender: maya, text: "These are the movies showing this weekend.", imageName: "movie-posters", date: .now.addingTimeInterval(-300) ), ChatMessage( id: UUID(), sender: anton, text: "Let’s watch The Last Horizon on Saturday.", imageName: nil, date: .now.addingTimeInterval(-240) ), ChatMessage( id: UUID(), sender: maya, text: "The 19:30 screening at Central Cinema works for me.", imageName: nil, date: .now.addingTimeInterval(-180) ), ChatMessage( id: UUID(), sender: anton, text: "Great. Let’s meet there. Will add to notes to bring your favourite popcorn!", imageName: nil, cinemaLocation: nil, date: .now.addingTimeInterval(-120) ) ]}The last two messages give the framework enough context to recognize a date, time, and cinema-related plan.SwiftUI message cellThe cell displays an optional image, a message bubble, and the system-provided actions underneath:struct MessageCell: View { let message: ChatMessage let previousMessages: [ChatMessage] var body: some View { VStack( alignment: message.sender.isCurrentUser ? .trailing : .leading, spacing: 8 ) { if let imageName = message.imageName { Image(imageName) .resizable() .scaledToFill() .frame(width: 240, height: 150) .clipShape( RoundedRectangle(cornerRadius: 18) ) } Text(message.text) .padding(.horizontal, 14) .padding(.vertical, 10) .background( message.sender.isCurrentUser ? Color.accentColor : Color.secondary.opacity(0.15) ) .foregroundStyle( message.sender.isCurrentUser ? .white : .primary ) .clipShape( RoundedRectangle(cornerRadius: 18) ) SuggestedActionsView( message: message.suggestedActionsMessage, previousMessages: previousMessages .suffix( SuggestedActionsMessage .previousMessagesLimit ) .map(\.suggestedActionsMessage) ) .buttonBorderShape(.capsule) .tint(.blue) .font(.callout) } .frame( maxWidth: .infinity, alignment: message.sender.isCurrentUser ? .trailing : .leading ) }}There is no conditional around SuggestedActionsView. When the system has nothing useful to show, the view collapses to zero size.Complete chat screenstruct MovieChatView: View { private let messages = ChatMessage.demo var body: some View { ScrollView { LazyVStack(spacing: 16) { ForEach( Array(messages.enumerated()), id: \.element.id ) { index, message in MessageCell( message: message, previousMessages: Array( messages.prefix(index) ) ) } } .padding() } .navigationTitle("Movie Night") }}Each cell receives only the messages that appeared before it. This prevents a future reply from influencing an earlier suggestion.The framework also limits how much previous context it accepts. Applying previousMessagesLimit keeps the input within the supported range.This is how a generated actions are looking in Simulator. Location and Calendar are linked to the corresponding cells. Amazing!Pre-generating ActionsSuggestedActionsView can generate actions when it appears, but that may briefly show a loading state.You can generate and cache the result earlier:private func prepareActions( for message: ChatMessage, previousMessages: [ChatMessage]) async { await SuggestedActionsView.generate( message: message.suggestedActionsMessage, previousMessages: previousMessages .suffix( SuggestedActionsMessage .previousMessagesLimit ) .map(\.suggestedActionsMessage) )}Required entitlementThe framework requires the Suggested Actions entitlement:com.apple.developer.suggested-actionsAdd the Suggested Actions capability to the app target before testing the view.The entitlement defaults to false, so importing the framework and adding the view is not enough by itself.What the App controlsThe application provides:the current messagea limited amount of previous contextparticipant names and handlesthe surrounding layout and visual modifiersThe system controls:whether an action is relevantwhich action appearsthe button contentthe action’s system behaviorThis is different from Foundation Models. There is no prompt, LanguageModelSession, custom schema, or tool implementation. Suggested Actions is a focused system feature for messaging interfaces.Where it fitsThe framework is useful for chat, email, support, collaboration, and marketplace apps where messages regularly contain dates, reminders, or locations.It should not be treated as a replacement for app-specific actions. If a cinema app needs a guaranteed Buy Tickets button, that action still belongs to the application. Suggested Actions is better for contextual system tasks that may or may not apply to a particular message.📢 Important: MobilePro is Moving to SubstackWe’ll be moving MobilePro to Substack soon. From that point forward, all issues will come frompacktmobilepro@substack.com.To ensure uninterrupted delivery, please whitelist this address in your mail client. No other action is required.You’ll continue receiving the newsletter on the same weekly cadence, and on Substack you’ll also gain more granular control over your preferences if you wish to adjust them later.💭 Let’s TalkWhat's one repetitive task in your app you'd love the platform to handle automatically?Reply and let us know.Advertise with usInterested in sponsoring this newsletter and reaching a highly engaged audience of tech professionals? Simply reply to this email and our team will get in touch with next steps.Cheers,Nithya Sadanandan and Runcil Rebello,Editors-in-Chief, MobilePro*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0}#converted-body .list_block ol,#converted-body .list_block ul,.body [class~=x_list_block] ol,.body [class~=x_list_block] ul,u+.body .list_block ol,u+.body .list_block ul{padding-left:20px} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;display:none;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}.social_block .social-table{display:inline-block!important}}

Our Data Engineering Byte Newsletter gives data engineers and practitioners what they often lack today: clear, real-world insights—where every byte tells a story.Subscribe here to stay ahead in data engineeringIntroductionLiquid Clustering is Databricks’ modern approach to organizing Delta Lake data for faster, more adaptable query performance. Unlike traditional partitioning and Z-Ordering, it supports flexible clustering on high-cardinality columns, allows clustering keys to change over time, and reduces the operational complexity of managing static data layouts. This article explains how Liquid Clustering works, why it is becoming the recommended strategy for newer Databricks runtimes, and how to apply it to both new and existing Delta tables.Performance Tuning for Spark and Delta LakePerformance tuning idx_be4976b8is a continuous process of identifying and eliminating bottlenecks to make your data workloads run faster and more efficiently. In the Databricks idx_369af902ecosystem, this involves optimizing at two primary levels: the storage layer, represented by Delta Lake, and the processing layer, powered by Apache Spark.This initial section of the chapter will focus exclusively on these foundational tuning techniques. We will cover the essentials of structuring your data on disk with Delta Lake (using compaction, Liquid Clustering, Z-Ordering, and partitioning) and influencing Spark's processing behavior (through join strategies, predicate pushdown, column pruning, and shuffle management). Later sections will build on this foundation by exploring automatic optimization features like AQE and cost management strategies. By the end of this section, you will have a strong command of the manual tuning levers that give you granular control over your data platform's performance.The Philosophy of OptimizationBefore diving idx_d589e068into specific commands and configurations, it's crucial to adopt the right mindset for optimization. Performance tuning is not about blindly applying a checklist of best practices. It is an iterative, scientific process:1. Measure: Establish a baseline. Before making any changes, measure the performance and cost of your current workload. Use Spark UI, logs, and cost monitoring tools to understand where time and money are being spent.2. Identify: Based on your measurements, form a hypothesis about the primary bottleneck. Is it I/O bound? Is there data skew? Is the cluster under-provisioned?3. Change: Make one, and only one, change based on your hypothesis. This could be adding a Z-ORDER clause, changing a join strategy, or adjusting a cluster configuration.4. Measure Again: Rerun idx_c630efefthe workload and measure its performance and cost again. Compare the results to your baseline.5. Analyze: Did the change have the intended effect? Did it improve performance, reduce cost, or both? Sometimes, a change that improves performance can increase costs, or vice versa. Understanding these trade-offs is key.By following this iterative loop, you can systematically improve your workloads based on datadriven evidence rather than guesswork.Advanced Storage Layer Optimization with Delta LakeOptimizing idx_2ea802cfthe storage layer is about arranging data on disk to minimize the amount of data that Spark needs to read. Less data read means less I/O, less network traffic, and faster queries.Delta Lake's transactional format provides a powerful foundation for performance, but its true potential is unlocked through deliberate optimization of the underlying data layout. How you organize the data files on disk directly impacts how quickly Spark can find and read the data it needs. This section covers the key techniques for tuning your Delta tables.File Compaction and the Small File ProblemStreaming idx_211d11c3ingestion or frequent small updates can lead to a common big-data ailment: the "small file problem." When a table is composed of thousands of small files, the overhead of opening, reading, and closing each file overwhelms the query engine, crippling read performance. The OPTIMIZE command solves this by compacting small files into larger, more optimally sized ones. While 1 GB is the general default target for OPTIMIZE, Unity Catalogmanaged tables use automatic file size tuning to determine the optimal file size based on table operations intelligently.You can run the OPTIMIZE command on a table using the following SQL syntax:-- Compact small files for the entire table OPTIMIZE events; -- Compact files only for a specific partition OPTIMIZE events WHERE date = '2024-02-15';Running OPTIMIZE periodically is a critical maintenance task for any Delta table that is frequently updated. For many workloads, Databricks can handle this automatically by compacting files during writes, preventing the small-file problem from developing in the first place. You can enable automatic file size tuning using autoOptimize, autoCompact, and autoOptimize.optimizeWrite table properties. autoCompact runs a lightweight background compaction job after a write operation is complete, while optimizeWrite dynamically optimizes partition sizes during the write operation itself.For Unity Catalog-managed tables, Predictive Optimization is now the recommended approach. Predictive optimization is enabled by default and intelligently schedules maintenance operations such as OPTIMIZE and VACUUM based on data access patterns and table statistics, ensuring your tables remain performant without manual intervention.If you idx_35ac5bacare working with external tables where Predictive Optimization is not available, you will sometimes need to run the OPTIMIZE command manually. The best times to run this command are:After large batch loads: If you ingest a massive amount of data in a single batch, running OPTIMIZE immediately afterward ensures subsequent reads are fast.On a regular schedule: For tables with continuous streaming ingest or frequent small updates, schedule an OPTIMIZE job to run daily or weekly during off-peak hours.Before critical queries: If you have a complex, long-running reporting query, running OPTIMIZE beforehand can significantly reduce its execution time.Data SkippingDelta Lake automatically collects statistics (min/max values) for the first 32 columns in a table.When you idx_5d274511query the table, Spark uses idx_74645d71these statistics to skip files that do not contain datamatching your WHERE clause. For example, if a file's maximum timestamp is from yesterday, and your query filters for today's data, Spark ignores that file entirely. You can customize this behavior using the delta.dataSkippingStatsColumns or delta.dataSkippingNumIndexedCols table properties to change which columns have statistics collected.Z-OrderingZ-Ordering idx_8152444cis a technique for co-locating idx_d8164490related information within a single set of files. This significantly enhances the effectiveness of data skipping. If you frequently filter by a specific column (e.g., customerId), Z-Ordering by that column ensures that data for a given customer is concentrated in a few files, rather than scattered across the entire table.It's important to understand the difference between Z-Ordering and partitioning. Partitioning physically separates data into different directories based on one or more columns. Z-Ordering, on the other hand, arranges data within files. They are not mutually exclusive and can be used together. A common idx_01a78cf9pattern is to partition by a low-cardinality column (like date) and then ZOrder by higher-cardinality columns (like userId or productId).Here is idx_4b03b7c0an example of how to apply Z-Ordering alongside partitioning during an optimization run:-- Partition by date and Z-Order by userId OPTIMIZE events WHERE date = '2024-02-15' ZORDER BY (userId);Partitioning StrategiesJust as OPTIMIZE organizes data within files, partitioning organizes files within directories.Partitioning idx_2e8225a1your Delta table by a low-cardinality column (like date or country) that is almost always used as a filter can provide a massive performance boost. This is because Spark can perform partition pruning, ignoring entire directories of data that are not relevant to the query.The following code demonstrates how to create a partitioned table using SQL:-- Create a partitioned table CREATE TABLE events ( -- columns ) PARTITIONED BY (date);However, be cautious. Partitioning by a high-cardinality column (like userId) can create millions of tiny partitions, reintroduce the small-file problem, and degrade performance.Databricks idx_a9fb4524recommendations are based on the table's size instead of the number of distinct values. The documentation guidance is more conservative: you should not partition tables below 1 TB, and each partition should contain at least 1 GB of data.Generated Columns for PartitioningSometimes, you don't have a perfect low-cardinality column to partition by. In these legacy cases, you could idx_39d9f1ceuse generated columns. For example, if you want to partition by timestamp but the raw timestamp has too high cardinality, you can generate a date column from the timestamp and partition by that. It is important to note that Liquid clustering handles high cardinality natively. Generated columns were a clever workaround specifically designed to make high-cardinality columns usable for Hive-style partitioning.Here is an example of creating a generated column for partitioning:-- Create a table with a generated column for partitioning CREATE TABLE events ( eventId STRING, eventTimestamp TIMESTAMP, -- other columns eventDate DATE GENERATED ALWAYS AS (CAST(eventTimestamp AS DATE)) ) PARTITIONED BY (eventDate);Liquid Clustering: The Modern ApproachFor newer idx_381a7e56Databricks runtimes, Liquid Clustering is replacing traditional partitioning and ZOrdering as the recommended best practice. Liquid Clustering is a more flexible and adaptive way to organize data. Instead of being constrained by static partition boundaries, it can dynamically cluster data based on the columns you choose, even if those columns have high cardinality. This simplifies data layout management and provides better performance across a wider range of query patterns.-- Create a table with liquid clustering CREATE TABLE events (...) CLUSTER BY (eventType, sourceIP); -- Automatic liquid clustering allows Databricks to intelligently choose clustering keys CREATE TABLE events (...) CLUSTER BY AUTO; -- OPTIMIZE automatically reclusters the data OPTIMIZE events;You can enable liquid clustering on existing tables and change clustering keys at any time by running an ALTER TABLE command:-- Enable or change clustering keys on an existing table ALTER TABLE events CLUSTER BY (newColumn);Advanced Processing Layer Tuning with SparkWhile idx_bafc5080Delta Lake optimizes idx_99168c5edata access, Spark tuning focuses on how the data is processed in memory across the cluster. This involves influencing Spark's query plan to ensure that operations such as joins and aggregations are executed as efficiently as possible, leveraging techniques such as predicate pushdown and column pruning.Join and Shuffle OptimizationShuffling—the process of redistributing data across the cluster for operations like joins and aggregations—is one idx_f8a09215of the most expensive operations in Spark. A major goal of performance tuning is to minimize or avoid shuffles. Spark employs several join strategies, including sortmerge joins (which sort data on both sides before merging) and shuffle hash joins (which build a hash table on the smaller side and stream the larger side).When joining a large table to a small table, you can often avoid a shuffle entirely by using a broadcast join. This sends a copy of the small table to every node in the cluster, allowing the join to happen locally without data movement. Spark's automatic broadcast decision is governed by the spark.sql.autoBroadcastJoinThreshold configuration, which has a default value of 10 MB.Spark often figures this out on its own, but providing an explicit hint can be beneficial. Here is how you can explicitly hint to Spark to use a broadcast join in PySpark:from pyspark.sql.functions import broadcast # Hint to Spark to broadcast the smaller DataFrame large_df.join(broadcast(small_df), "join_key")Spark often figures this out on its own, but providing an explicit hint can be beneficial. This is a key area where Adaptive Query Execution, which we discuss next, provides significant automatic improvements.Tuning Shuffle PartitionsThe idx_1c884dfbnumber of partitions used during a shuffle is controlled by thespark.sql.shuffle.partitions configuration. The default is 200, which might not be optimal for all workloads. If you have very large datasets, you may need to increase this value to provide more parallelism. If you have smaller datasets, you might decrease them to reduce overhead. This is a parameter that often requires experimentation to find idx_e87d2d81the sweet spot for your specific workload.You can adjust this configuration for your current session using the following code:# Set the number of shuffle partitions for the current session spark.conf.set("spark.sql.shuffle.partitions", 400)The Perils of User-Defined Functions (UDFs)UDFs allow you to execute custom Python or Scala code on your data. While they offer greatflexibility, they can idx_6c5631d0be a major performance idx_38fb5efcbottleneck. Spark treats UDFs as black boxes and cannot apply its own optimizations to the code inside them. Whenever possible, you should use Spark's built-in functions, which are highly optimized. If you must use a UDF, consider idx_c66cb8c4using a Pandas UDF (also idx_6f623f94known as a vectorized UDF), which operates on Arrow record batches and can be significantly faster than row-at-a-time Python UDFs.Mastering these manual tuning techniques provides a strong foundation for optimizing your workloads. Now, let's explore how Databricks can automate much of this work for us with features like Adaptive Query Execution and intelligent caching.ConclusionLiquid Clustering gives data teams a more flexible and scalable way to optimize Delta Lake tables. By dynamically organizing data around selected clustering keys, it can improve data skipping, support evolving query patterns, and avoid many of the limitations associated with static partitioning and Z-Ordering. For modern Databricks workloads, it offers a simpler path to maintaining efficient data layouts while preserving the ability to update clustering strategies as business and performance requirements change.This article is adapted from an excerpt from the book Data Engineering with Azure Databricks. Author BioTonya Chernyshova is an experienced Data Engineer with over 10 years in the field, including time at Amazon. Specializing in Data Modeling, Automation, Cloud Computing (AWS and Azure), and Data Visualization, she has a strong track record of delivering scalable, maintainable data products. Her expertise drives data-driven insights and business growth, showcasing her proficiency in leveraging cloud technologies to enhance data capabilities.Dmitry Foshin is a Business Intelligence team leader focused on delivering business insights to the management team through data engineering, analytics, and visualization. He has led and executed complex full-stack BI solutions (from ETL processes to building DWHs and reporting) using Azure technologies, Data Lake, Data Factory, Data Bricks, MS Office 365, Power BI, and Tableau. He has also successfully launched numerous data analytics projects - both on-premises and in the cloud - that help achieve corporate goals for international FMCG companies, banks, and manufacturing companies.Dmitry Anoshin is a data-centric technologist and a recognized expert in building and implementing big data and analytics solutions. He has a successful track record of implementing business and digital intelligence projects across retail, finance, marketing, and e-commerce. Dmitry possesses in-depth knowledge of digital/business intelligence, ETL, data warehousing, and big data technologies. He has extensive experience in data integration and is proficient in various data warehousing methodologies. Dmitry has consistently exceeded project expectations across the financial, machine tool, and retail industries. He has completed a number of multinational full BI/DI solution life cycle implementation projects. With expertise in data modeling, Dmitry also has a background and business experience in multiple relational databases, OLAP systems, and NoSQL databases. He is also an active speaker at data conferences and helps people to adopt cloud analytics.Sergii Volodarskyi is a Data Engineer working daily on the Databricks ecosystem, across both platform and product data engineering. His expertise spans the full spectrum of modern data platform delivery, from designing lakehouse architectures and building CI/CD pipelines to extracting data from APIs and shipping analytical products that drive business decisions. This book is a reflection of experience and best practices built up across real projects. He actively shares his knowledge with the engineering community and is a builder with a deep interest in the intersection of data, AI, and software engineering.