Databricks Placement Papers 2026

Truth check — what actually matters for Databricks 2026

Databricks India's 2026 hiring at the Bangalore engineering center is small-volume and premium-positioned, with the bar sitting at FAANG-tier or above for fresher SDE. This is one of the most selective funnels in Indian product engineering.

The 2026 funnel: 1 OA + 4-5 technical onsite + behavioral. The OA is LeetCode-medium-to-hard with strict time pressure. The onsite probes distributed-systems fundamentals at depth, Spark internals, query optimization, partition reasoning, fault-tolerance patterns. This is closer to a senior-IC interview than a fresher loop.

What guides get wrong: standard "Databricks placement papers" content is functionally non-existent because the funnel is too narrow to have produced a templated prep ecosystem. The right prep is FAANG-tier DSA plus distributed-systems-fundamentals depth.

The HR / behavioral round at Databricks is rigorous, they probe ownership, ambiguity-tolerance, and learning-velocity with multi-example STAR-format. Generic loyalty answers do not score.

If you have 2 weeks for Databricks only: 6 days of LeetCode-medium-to-hard at 80%+ solve rate; 4 days of distributed-systems fundamentals (consistency, fault-tolerance, MapReduce-and-beyond); 2 days of Spark + Databricks-platform basics; 2 days of behavioral STAR with multi-example fluency.

Eligibility Criteria

Databricks Selection Process 2026

1. Resume Shortlisting – Databricks highly values open-source contributions (especially Spark, Delta Lake, MLflow), data engineering projects, and research publications. A Kaggle ranking or ML competition background helps significantly.

2. Recruiter Phone Screen – 30-minute conversation about background, technical interests, and why Databricks. The recruiter will probe data engineering knowledge at a surface level.

3. Online Technical Assessment – 2 coding problems on HackerRank/LeetCode-style platform. 90 minutes. Typically includes 1 medium and 1 medium-hard problem. Some assessments include a SQL query problem.

4. Technical Interview Round 1 (Coding) – 60-minute live coding interview. Problems often relate to data processing, string manipulation, or graph algorithms. Focus on clean, efficient code.

5. Technical Interview Round 2 (Data Engineering / Systems) – Discussion of data pipeline design, Spark concepts, SQL optimization, and distributed systems fundamentals. May include a whiteboard problem around data processing at scale.

6. Technical Interview Round 3 (ML or Platform) – Depending on the role: ML engineers get ML system design and model evaluation questions; platform engineers get deeper distributed systems questions.

7. Behavioral Interview – Focused on Databricks' values: customers first, quality, openness, and innovation. STAR format expected.

8. Final Offer – Reference checks and offer within 1–2 weeks of final round.

Exam Pattern

Practice Questions with Detailed Solutions

Aptitude / Analytical

Q1. A data pipeline processes 1 million records per hour. How many records can it process in 8 hours if throughput drops by 15% every 2 hours?

Solution:

• Hour 1–2: 1M/hr × 2 hrs = 2M
• Hour 3–4: 1M × 0.85 × 2 = 1.7M
• Hour 5–6: 1M × 0.85² × 2 = 1.445M
• Hour 7–8: 1M × 0.85³ × 2 = 1.228M
• Total ≈ 2 + 1.7 + 1.445 + 1.228 = 6.373M records

✅ Answer: ~6.37 million records

Q2. If a Spark job uses 20 executors each with 4 cores, and processes 800 partitions, what is the minimum number of waves needed?

Solution:

• Total parallel task capacity = 20 executors × 4 cores = 80 tasks simultaneously
• Waves needed = ⌈800 / 80⌉ = 10 waves

✅ Answer: 10 waves (This type of analytical question appears in Databricks technical screens)

Q3. A 2 TB dataset is stored in Parquet format with a 10:1 compression ratio. What was the original uncompressed size?

Solution:

• Compressed size = 2 TB
• Compression ratio = 10:1 → uncompressed = 2 × 10 = 20 TB

✅ Answer: 20 TB

Q4. In a sequence 1, 1, 2, 3, 5, 8, 13, 21, what is the ratio of the 10th term to the 9th term (Fibonacci)?

Solution:

• Fibonacci terms: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55
• 9th term = 34, 10th term = 55
• Ratio = 55/34 ≈ 1.617 (Golden ratio φ)

✅ Answer: 55/34 ≈ 1.617

Q5. A SQL query without an index scans 10M rows in 5 seconds. After adding an index, it uses B-tree lookup: O(log n) vs O(n). Estimate new query time.

Solution:

• Without index: O(n) = 10M rows in 5s → each row unit = 5/10M = 0.0000005s
• With index: O(log 10M) ≈ O(23.25) steps
• Estimated time = 23.25 × 0.0000005 ≈ ~0.0000116 seconds (much faster in theory)
• In practice, index queries are 100x–1000x faster on large tables

✅ Key insight: Index reduces full scan to logarithmic lookup

Coding Questions

Q6. Word Count using MapReduce paradigm (Core Spark concept).

from collections import defaultdict

def word_count_mapreduce(documents):
    """
    Simulate MapReduce word count.
    Map phase: emit (word, 1) for each word
    Reduce phase: sum counts per word
    """
    # MAP phase
    mapped = []
    for doc in documents:
        for word in doc.lower().split():
            word = word.strip('.,!?')
            mapped.append((word, 1))
    
    # SHUFFLE & SORT (group by key)
    grouped = defaultdict(list)
    for word, count in mapped:
        grouped[word].append(count)
    
    # REDUCE phase
    reduced = {word: sum(counts) for word, counts in grouped.items()}
    
    return dict(sorted(reduced.items(), key=lambda x: x[1], reverse=True))

# Example
docs = [
    "data engineering is powerful",
    "data science and data engineering",
    "apache spark powers data processing"
]
print(word_count_mapreduce(docs))

# PySpark equivalent:
# rdd = sc.parallelize(docs)
# result = rdd.flatMap(lambda x: x.split()) \
#             .map(lambda word: (word, 1)) \
#             .reduceByKey(lambda a, b: a + b)

Q7. Implement a simplified ETL pipeline with transformation and validation.

from typing import List, Dict, Optional
from datetime import datetime

class ETLPipeline:
    def __init__(self):
        self.errors = []
        self.processed = 0
    
    def extract(self, raw_data: List[Dict]) -> List[Dict]:
        """Extract: return raw records."""
        return raw_data
    
    def transform(self, records: List[Dict]) -> List[Dict]:
        """Transform: clean and normalize records."""
        transformed = []
        
        for record in records:
            try:
                # Normalize
                cleaned = {
                    'user_id': str(record.get('user_id', '')).strip(),
                    'amount': float(record.get('amount', 0)),
                    'currency': record.get('currency', 'USD').upper(),
                    'timestamp': self._parse_timestamp(record.get('timestamp')),
                    'status': record.get('status', 'unknown').lower()
                }
                
                # Validate
                if not cleaned['user_id']:
                    raise ValueError("Missing user_id")
                if cleaned['amount'] <= 0:
                    raise ValueError(f"Invalid amount: {cleaned['amount']}")
                
                transformed.append(cleaned)
                self.processed += 1
                
            except (ValueError, TypeError) as e:
                self.errors.append({'record': record, 'error': str(e)})
        
        return transformed
    
    def _parse_timestamp(self, ts) -> Optional[datetime]:
        if not ts:
            return None
        try:
            return datetime.fromisoformat(str(ts))
        except ValueError:
            return None
    
    def load(self, records: List[Dict]) -> Dict:
        """Load: simulate writing to Delta Lake / database."""
        return {
            'records_written': len(records),
            'errors': len(self.errors),
            'success_rate': f"{(self.processed / (self.processed + len(self.errors)) * 100):.1f}%"
        }
    
    def run(self, raw_data: List[Dict]) -> Dict:
        extracted = self.extract(raw_data)
        transformed = self.transform(extracted)
        return self.load(transformed)

# Test
pipeline = ETLPipeline()
raw = [
    {'user_id': 'u001', 'amount': 100.50, 'currency': 'usd', 'timestamp': '2026-03-01', 'status': 'SUCCESS'},
    {'user_id': '', 'amount': 50, 'currency': 'inr', 'timestamp': '2026-03-02', 'status': 'failed'},
    {'user_id': 'u003', 'amount': -10, 'currency': 'EUR', 'timestamp': '2026-03-03', 'status': 'success'},
]
result = pipeline.run(raw)
print(result)  # {'records_written': 1, 'errors': 2, 'success_rate': '33.3%'}

Q8. Median of Two Sorted Arrays (O(log(m+n)), Databricks loves this).

def find_median_sorted_arrays(nums1, nums2):
    """Binary search approach - O(log(min(m,n)))"""
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1  # nums1 must be shorter
    
    m, n = len(nums1), len(nums2)
    left, right = 0, m
    
    while left <= right:
        i = (left + right) // 2  # Partition point in nums1
        j = (m + n + 1) // 2 - i  # Partition point in nums2
        
        max_left1 = nums1[i-1] if i > 0 else float('-inf')
        min_right1 = nums1[i] if i < m else float('inf')
        max_left2 = nums2[j-1] if j > 0 else float('-inf')
        min_right2 = nums2[j] if j < n else float('inf')
        
        if max_left1 <= min_right2 and max_left2 <= min_right1:
            if (m + n) % 2 == 0:
                return (max(max_left1, max_left2) + min(min_right1, min_right2)) / 2
            else:
                return max(max_left1, max_left2)
        elif max_left1 > min_right2:
            right = i - 1
        else:
            left = i + 1

# Examples
print(find_median_sorted_arrays([1, 3], [2]))        # 2.0
print(find_median_sorted_arrays([1, 2], [3, 4]))     # 2.5
print(find_median_sorted_arrays([0, 0], [0, 0]))     # 0.0

Q9. Implement a simple version of Delta Lake, ACID writes with versioning.

import copy
from typing import List, Dict, Any

class DeltaTable:
    """
    Simplified Delta Lake: supports versioned, ACID writes.
    Tracks transaction log and allows time travel.
    """
    def __init__(self, name: str):
        self.name = name
        self.versions = {}   # version -> list of records
        self.current_version = 0
        self.transaction_log = []
        self.versions[0] = []  # Empty table at v0
    
    def insert(self, records: List[Dict]) -> int:
        """Insert records and create a new version."""
        new_version = self.current_version + 1
        new_data = copy.deepcopy(self.versions[self.current_version])
        new_data.extend(records)
        
        self.versions[new_version] = new_data
        self.current_version = new_version
        self.transaction_log.append({
            'version': new_version,
            'operation': 'INSERT',
            'record_count': len(records)
        })
        
        return new_version
    
    def delete(self, condition_key: str, condition_value: Any) -> int:
        """Delete records matching condition - creates new version."""
        new_version = self.current_version + 1
        current_data = self.versions[self.current_version]
        new_data = [r for r in current_data if r.get(condition_key) != condition_value]
        
        self.versions[new_version] = new_data
        self.current_version = new_version
        self.transaction_log.append({
            'version': new_version,
            'operation': 'DELETE',
            'condition': f"{condition_key}={condition_value}"
        })
        
        return new_version
    
    def read(self, version: int = None) -> List[Dict]:
        """Read table at a specific version (time travel)."""
        v = version if version is not None else self.current_version
        return copy.deepcopy(self.versions.get(v, []))
    
    def history(self) -> List[Dict]:
        return self.transaction_log

# Test
table = DeltaTable("events")
v1 = table.insert([{"id": 1, "event": "login"}, {"id": 2, "event": "purchase"}])
v2 = table.insert([{"id": 3, "event": "logout"}])
v3 = table.delete("id", 2)

print(f"Current: {table.read()}")    # 2 records (id 1 and 3)
print(f"At v1: {table.read(v1)}")    # 2 records (id 1 and 2)
print(f"History: {table.history()}")

Q10. Top K Frequent Elements (Heap + HashMap).

import heapq
from collections import Counter

def top_k_frequent(nums, k):
    count = Counter(nums)
    return heapq.nlargest(k, count.keys(), key=count.get)

# Better: bucket sort for O(n) time
def top_k_frequent_optimal(nums, k):
    count = Counter(nums)
    buckets = [[] for _ in range(len(nums) + 1)]
    
    for num, freq in count.items():
        buckets[freq].append(num)
    
    result = []
    for i in range(len(buckets) - 1, 0, -1):
        result.extend(buckets[i])
        if len(result) >= k:
            return result[:k]
    
    return result

# Examples
print(top_k_frequent([1, 1, 1, 2, 2, 3], 2))   # [1, 2]
print(top_k_frequent([1], 1))                    # [1]

Q11. SQL, Find the second highest salary (Classic SQL interview question).

-- Method 1: Using LIMIT with OFFSET
SELECT DISTINCT salary
FROM employees
ORDER BY salary DESC
LIMIT 1 OFFSET 1;

-- Method 2: Using subquery
SELECT MAX(salary) AS second_highest
FROM employees
WHERE salary < (SELECT MAX(salary) FROM employees);

-- Method 3: Using DENSE_RANK (preferred for Databricks/Spark SQL)
SELECT salary
FROM (
    SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
    FROM employees
) ranked
WHERE rnk = 2
LIMIT 1;

-- Databricks SQL (using CTE)
WITH ranked AS (
    SELECT salary, 
           DENSE_RANK() OVER (ORDER BY salary DESC) AS rnk
    FROM employees
)
SELECT salary AS SecondHighestSalary
FROM ranked
WHERE rnk = 2;

Q12. Implement MLflow Experiment Tracking (conceptual + code).

# MLflow is Databricks' open-source ML lifecycle platform
# In interviews, you may be asked to design or implement simplified tracking

class ExperimentTracker:
    """Simplified MLflow-style experiment tracker."""
    
    def __init__(self):
        self.experiments = {}
        self.current_run = None
    
    def create_experiment(self, name: str) -> str:
        exp_id = f"exp_{len(self.experiments):04d}"
        self.experiments[exp_id] = {
            'name': name,
            'runs': {}
        }
        return exp_id
    
    def start_run(self, experiment_id: str, run_name: str = None) -> str:
        exp = self.experiments.get(experiment_id)
        if not exp:
            raise ValueError(f"Experiment {experiment_id} not found")
        
        run_id = f"run_{len(exp['runs']):04d}"
        exp['runs'][run_id] = {
            'name': run_name or run_id,
            'params': {},
            'metrics': {},
            'artifacts': [],
            'status': 'RUNNING'
        }
        self.current_run = (experiment_id, run_id)
        return run_id
    
    def log_param(self, key: str, value):
        exp_id, run_id = self.current_run
        self.experiments[exp_id]['runs'][run_id]['params'][key] = value
    
    def log_metric(self, key: str, value: float, step: int = None):
        exp_id, run_id = self.current_run
        metrics = self.experiments[exp_id]['runs'][run_id]['metrics']
        if key not in metrics:
            metrics[key] = []
        metrics[key].append({'value': value, 'step': step})
    
    def end_run(self, status: str = "FINISHED"):
        exp_id, run_id = self.current_run
        self.experiments[exp_id]['runs'][run_id]['status'] = status
        self.current_run = None

# Usage - similar to real MLflow API
tracker = ExperimentTracker()
exp_id = tracker.create_experiment("fraud_detection_v1")
run_id = tracker.start_run(exp_id, "xgboost_baseline")

tracker.log_param("n_estimators", 100)
tracker.log_param("max_depth", 5)
tracker.log_param("learning_rate", 0.1)

for epoch in range(3):
    tracker.log_metric("train_auc", 0.85 + epoch * 0.02, step=epoch)
    tracker.log_metric("val_auc", 0.83 + epoch * 0.015, step=epoch)

tracker.end_run()
print(tracker.experiments[exp_id]['runs'][run_id])

Q13. Graph: Detect Cycle in a Directed Graph (relevant for DAG-based pipelines).

def has_cycle(graph):
    """
    Detect cycle in directed graph using DFS + color marking.
    0 = WHITE (unvisited), 1 = GRAY (in progress), 2 = BLACK (done)
    
    Relevant: Spark uses DAG (Directed Acyclic Graph) for execution plans.
    A cycle in a pipeline DAG means infinite execution.
    """
    color = {node: 0 for node in graph}
    
    def dfs(node):
        color[node] = 1  # Mark as in-progress
        
        for neighbor in graph.get(node, []):
            if color[neighbor] == 1:
                return True  # Back edge = cycle
            if color[neighbor] == 0:
                if dfs(neighbor):
                    return True
        
        color[node] = 2  # Mark as done
        return False
    
    for node in graph:
        if color[node] == 0:
            if dfs(node):
                return True
    
    return False

# Test
pipeline1 = {'A': ['B'], 'B': ['C'], 'C': ['D'], 'D': []}  # No cycle (valid DAG)
pipeline2 = {'A': ['B'], 'B': ['C'], 'C': ['A']}             # Cycle! (invalid)

print(has_cycle(pipeline1))  # False ✅
print(has_cycle(pipeline2))  # True ❌

Q14. Sliding Window Maximum (useful for time-series data in Spark streaming).

from collections import deque

def max_sliding_window(nums, k):
    """
    Find maximum in each sliding window of size k.
    Time: O(n), Space: O(k)
    """
    dq = deque()  # Monotonic decreasing deque (stores indices)
    result = []
    
    for i, num in enumerate(nums):
        # Remove elements outside window
        while dq and dq[0] < i - k + 1:
            dq.popleft()
        
        # Remove smaller elements (they'll never be maximum)
        while dq and nums[dq[-1]] < num:
            dq.pop()
        
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[dq[0]])
    
    return result

# Example
nums = [1, 3, -1, -3, 5, 3, 6, 7]
k = 3
print(max_sliding_window(nums, k))  # [3, 3, 5, 5, 6, 7]

Q15. Write a PySpark-style groupBy and aggregation.

# In an interview, you might be asked to simulate Spark's groupBy/agg behavior

from collections import defaultdict
from typing import List, Dict, Callable

def spark_groupby_agg(data: List[Dict], group_col: str, 
                       agg_col: str, agg_fn: Callable) -> List[Dict]:
    """
    Simulate Spark's: df.groupBy(group_col).agg(agg_fn(agg_col))
    """
    groups = defaultdict(list)
    
    for row in data:
        key = row[group_col]
        groups[key].append(row[agg_col])
    
    return [
        {group_col: key, f"{agg_fn.__name__}({agg_col})": agg_fn(values)}
        for key, values in groups.items()
    ]

# Example data: sales by region
sales_data = [
    {'region': 'North', 'revenue': 100},
    {'region': 'South', 'revenue': 200},
    {'region': 'North', 'revenue': 150},
    {'region': 'South', 'revenue': 300},
    {'region': 'East',  'revenue': 250},
]

result = spark_groupby_agg(sales_data, 'region', 'revenue', sum)
for row in result:
    print(row)
# {'region': 'North', 'sum(revenue)': 250}
# {'region': 'South', 'sum(revenue)': 500}
# {'region': 'East',  'sum(revenue)': 250}

HR Interview Questions with Sample Answers

Q1. Why Databricks over other data companies?

"Databricks is at the intersection of the two most important trends in enterprise tech, cloud data infrastructure and AI/ML. What draws me specifically is that Databricks actually built and open-sourced Apache Spark and Delta Lake, they're not just using these tools, they're shaping the entire data ecosystem. I want to work where the most important technical decisions are being made. Also, the engineering culture prioritizes openness, open source, open data formats, which aligns with how I think good software should be built."

Q2. Tell me about a data engineering or ML project you've built.

"I built a sales forecasting pipeline for a college hackathon that won second place. I used Python and PySpark (on a local cluster) to clean and join two datasets, historical sales and marketing spend. I then trained an XGBoost model, tracked experiments with MLflow, and deployed the model with a FastAPI endpoint. The hardest part was handling missing values in time-series data, I implemented forward-fill with a lookback limit. The model achieved 87% accuracy on holdout data. That project made me want to work at a company where data pipelines are the product."

Q3. How do you approach debugging a slow Spark job?

"I start with the Spark UI, looking at the DAG visualization to identify bottlenecks. I check for data skew first (are some partitions much larger?), then look at the number of stages and shuffles. Shuffles are usually the biggest performance killer. If I see a skewed join, I might add salting. I also check for unnecessary wide transformations and see if I can replace them with broadcast joins for small tables. If memory is an issue, I look at executor heap usage and spill metrics."

Q4. Describe a situation where you had to learn something completely new under time pressure.

"Three days before my internship presentation, I realized our team's recommendation system needed to be refactored to handle cold-start users, something we hadn't planned for. I had never implemented collaborative filtering before. I spent two days reading papers and a practical tutorial, then implemented a simple ALS (Alternating Least Squares) model using Spark MLlib for existing users and a fallback popularity-based recommender for cold-start. It wasn't perfect, but it worked and the presentation went well. The key was scoping the problem to what I could actually implement in time."

Q5. Where do you see data engineering going in the next 5 years?

"I think the biggest shift will be the convergence of LLMs and data pipelines, what people are starting to call 'LLM Ops' or 'AI Engineering'. Instead of writing SQL or Spark code manually, engineers will increasingly use AI to generate and optimize pipelines. But the underlying infrastructure, Delta Lake, reliable streaming, data quality monitoring, becomes MORE important, not less, because AI systems need clean, reliable data to work. I'm excited to build that infrastructure layer."

Preparation Tips

• Learn Apache Spark fundamentals, RDDs, DataFrames, transformations vs actions, lazy evaluation, shuffles. These are Databricks' bread and butter.
• Master SQL, Complex joins, window functions, CTEs, query optimization. Databricks SQL is a first-class product, and SQL questions are common.
• Contribute to open source, Even small contributions to Delta Lake or MLflow repositories are noticed by Databricks recruiters.
• Practice on Databricks Community Edition, It's free. Build actual Spark notebooks, work with Delta tables, run MLflow experiments. Real-world experience shows.
• Understand the Lakehouse architecture, Know why it's better than a traditional data warehouse + data lake combo. Be able to explain it clearly.
• LeetCode Medium consistently, The coding bar is high. Practice arrays, graphs, DP, and sorting problems. Bonus: practice writing efficient Pandas code.
• Study distributed systems, Understand partitioning, fault tolerance, consistency models, and CAP theorem. These concepts come up in system design rounds.

🎯 Live Mock Test, May 2026 Edition

5 original questions written by Aditya Sharma, calibrated to the Databricks 2026 batch difficulty. Click any option to lock your answer; solutions reveal after.