Data Analyst Interview Questions Italy 2026: Advanced SQL, Python and Case Studies

Data Analyst interviews in Italy follow a structured format that differs from other European markets. Italian companies, from Milan-based fintech startups to Rome's established enterprises, emphasize SQL proficiency, Python data manipulation, and business case reasoning. This guide covers the actual questions candidates face in 2026.

SQL Questions Italian Companies Ask in 2026

SQL remains the foundation of every Data Analyst interview in Italy. Companies like Intesa Sanpaolo, Enel, and UniCredit use standardized SQL assessments before the first technical call. The questions below come from real interviews conducted in Milan, Rome, and Turin.

Window Functions for Ranking and Running Totals

Window functions appear in 80% of Italian Data Analyst interviews. This question tests cumulative revenue calculation:

-- Calculate running total of daily revenue by product category
SELECT 
    order_date,
    category,
    daily_revenue,
    SUM(daily_revenue) OVER (
        PARTITION BY category 
        ORDER BY order_date
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS cumulative_revenue
FROM (
    SELECT 
        DATE(order_timestamp) AS order_date,
        p.category,
        SUM(oi.quantity * oi.unit_price) AS daily_revenue
    FROM order_items oi
    JOIN products p ON oi.product_id = p.id
    GROUP BY DATE(order_timestamp), p.category
) daily_sales
ORDER BY category, order_date;

The ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW clause is explicit here. While PostgreSQL and MySQL 8+ default to this behavior with ORDER BY, interviewers expect candidates to demonstrate awareness of frame boundaries. Omitting it in BigQuery can produce different results with duplicate values.

CTEs for Multi-Step Analysis

Common Table Expressions (CTEs) test a candidate's ability to break down complex problems. Italian interviewers favor this pattern because it mirrors how analysts document their work:

-- Find customers who increased spending by 20%+ quarter over quarter
WITH quarterly_spending AS (
    SELECT 
        customer_id,
        DATE_TRUNC('quarter', order_date) AS quarter,
        SUM(total_amount) AS quarter_total
    FROM orders
    WHERE order_date >= '2025-01-01'
    GROUP BY customer_id, DATE_TRUNC('quarter', order_date)
),
spending_growth AS (
    SELECT 
        customer_id,
        quarter,
        quarter_total,
        LAG(quarter_total) OVER (
            PARTITION BY customer_id ORDER BY quarter
        ) AS prev_quarter_total
    FROM quarterly_spending
)
SELECT 
    customer_id,
    quarter,
    quarter_total,
    prev_quarter_total,
    ROUND(
        (quarter_total - prev_quarter_total) / prev_quarter_total * 100, 
        2
    ) AS growth_pct
FROM spending_growth
WHERE prev_quarter_total IS NOT NULL
  AND (quarter_total - prev_quarter_total) / prev_quarter_total >= 0.20
ORDER BY growth_pct DESC;

The CTE approach separates the aggregation step from the window function step. This prevents confusion about when LAG evaluates, a common source of errors when analysts try to combine these operations in a single query.

For more SQL patterns used in interviews, see the SQL Window Functions module.

Python Pandas Questions for Italian Interviews

Python has overtaken Excel as the expected tool for data manipulation in Italian Data Analyst roles. Companies test pandas specifically because it reveals how candidates handle real-world data cleaning tasks.

Data Cleaning and Type Conversion

This question appears in interviews at Italian e-commerce companies and tests practical data preparation:

# sales_data_cleaning.py
import pandas as pd
import numpy as np

def clean_sales_data(df: pd.DataFrame) -> pd.DataFrame:
    """Clean raw sales data from Italian ERP export."""
    # Create copy to avoid modifying original
    cleaned = df.copy()
    
    # Italian number format: 1.234,56 -> 1234.56
    if cleaned['revenue'].dtype == 'object':
        cleaned['revenue'] = (
            cleaned['revenue']
            .str.replace('.', '', regex=False)  # Remove thousand separator
            .str.replace(',', '.', regex=False)  # Decimal comma to point
            .astype(float)
        )
    
    # Parse Italian date format: 15/09/2026
    cleaned['order_date'] = pd.to_datetime(
        cleaned['order_date'], 
        format='%d/%m/%Y',
        errors='coerce'
    )
    
    # Handle missing values based on column type
    cleaned['customer_segment'] = cleaned['customer_segment'].fillna('Unknown')
    cleaned['revenue'] = cleaned['revenue'].fillna(0)
    
    # Remove duplicates keeping first occurrence
    cleaned = cleaned.drop_duplicates(
        subset=['order_id'], 
        keep='first'
    )
    
    return cleaned

The Italian number format (period as thousand separator, comma as decimal) catches candidates who only practiced with US-formatted data. The errors='coerce' parameter converts unparseable dates to NaT rather than raising an exception, which is the expected behavior in production pipelines.

GroupBy with Multiple Aggregations

This question tests understanding of pandas aggregation patterns:

# customer_metrics.py
import pandas as pd

def calculate_customer_metrics(orders_df: pd.DataFrame) -> pd.DataFrame:
    """Calculate customer-level metrics for RFM analysis."""
    reference_date = orders_df['order_date'].max()
    
    metrics = orders_df.groupby('customer_id').agg(
        recency=('order_date', lambda x: (reference_date - x.max()).days),
        frequency=('order_id', 'nunique'),
        monetary=('revenue', 'sum'),
        avg_order_value=('revenue', 'mean'),
        first_order=('order_date', 'min'),
        last_order=('order_date', 'max')
    ).reset_index()
    
    # Calculate customer lifetime in days
    metrics['customer_lifetime'] = (
        metrics['last_order'] - metrics['first_order']
    ).dt.days
    
    return metrics

The named aggregation syntax (recency=('order_date', lambda x: ...)) appeared in pandas 0.25 and remains the preferred approach in 2026. Italian interviewers specifically check if candidates use this over the deprecated agg({'column': 'function'}) dictionary syntax.

The Python Pandas Basics module covers additional patterns for interview preparation.

Case Study Questions from Italian Companies

Italian interviews include a case study round in 70% of Data Analyst positions. The candidate receives a dataset (usually anonymized company data) and must present findings within 24-48 hours.

E-Commerce Conversion Analysis

A typical case study from an Italian fashion e-commerce company:

"Analyze the attached dataset of 50,000 user sessions. Identify why mobile conversion dropped 15% in August compared to July. Present three actionable recommendations."

Expected deliverables:

1. Funnel breakdown by device type: Compare desktop vs mobile at each stage (landing, product view, add to cart, checkout, purchase)
2. Segment analysis: Check if the drop affects all traffic sources or specific channels (paid social often underperforms on mobile)
3. Technical investigation: Look for page load time increases, error rates, or UI changes that coincided with the drop

# conversion_funnel.py
import pandas as pd

def analyze_funnel(sessions_df: pd.DataFrame) -> pd.DataFrame:
    """Calculate conversion funnel by device and month."""
    sessions_df['month'] = sessions_df['session_start'].dt.to_period('M')
    
    funnel = sessions_df.groupby(['month', 'device_type']).agg(
        sessions=('session_id', 'nunique'),
        product_views=('viewed_product', 'sum'),
        add_to_cart=('added_to_cart', 'sum'),
        checkouts=('started_checkout', 'sum'),
        purchases=('completed_purchase', 'sum')
    ).reset_index()
    
    # Calculate conversion rates
    funnel['view_rate'] = funnel['product_views'] / funnel['sessions']
    funnel['cart_rate'] = funnel['add_to_cart'] / funnel['product_views']
    funnel['checkout_rate'] = funnel['checkouts'] / funnel['add_to_cart']
    funnel['purchase_rate'] = funnel['purchases'] / funnel['checkouts']
    funnel['overall_conversion'] = funnel['purchases'] / funnel['sessions']
    
    return funnel

Italian interviewers evaluate the presentation as much as the analysis. Structuring findings as "problem, evidence, recommendation" with specific numbers beats a lengthy exploratory narrative.

Financial Services Risk Assessment

Banks like Intesa Sanpaolo and UniCredit use case studies focused on risk metrics:

"Using the provided loan dataset, build a simple scoring model to predict default risk. Explain your feature selection rationale."

This tests understanding of:

• Feature engineering: Debt-to-income ratio, payment history aggregation, credit utilization
• Handling imbalanced data: Default rates are typically 2-5%, requiring stratified sampling or oversampling techniques
• Regulatory awareness: Italian banking regulations (Banca d'Italia guidelines) require explainable models, so black-box approaches score lower

What Italian Interviewers Look For Beyond Technical Skills

Technical skills get candidates to the final round. Cultural fit determines the offer. Italian companies evaluate:

Communication style: Italians value relationship building. Rushing through small talk to "get to the point" reads as rude. Take time during introductions.

Collaboration signals: Questions like "Tell me about a time you disagreed with a stakeholder" test whether candidates can navigate Italian workplace hierarchies, which tend to be more formal than Nordic or US companies.

Domain curiosity: Asking informed questions about the company's industry shows preparation. An analyst interviewing at Luxottica should understand eyewear market dynamics. At Ferrari, knowledge of luxury automotive metrics matters.

Salary Expectations and Market Context 2026

Data Analyst salaries in Italy for 2026, based on Glassdoor and LinkedIn data:

Milan pays 15-20% more than other Italian cities due to concentration of financial services and tech companies. Remote-first roles at international companies often exceed local rates because they compete for pan-European talent.

The Italian contratto a tempo indeterminato (permanent contract) remains the preferred employment type. Fixed-term contracts (tempo determinato) convert to permanent after 24 months under current labor law.

Preparing for Italian Data Analyst Interviews: Key Takeaways

• SQL window functions and CTEs appear in 80% of technical screens. Practice the specific patterns shown above, not generic tutorials
• Python pandas questions focus on data cleaning with Italian formats (comma decimals, European dates) and groupby aggregations with named syntax
• Case studies require structured presentations with quantified recommendations. "Increase conversion by X%" beats "improve user experience"
• The technical test typically runs 60-90 minutes on Codility or HackerRank. Practice timed coding to avoid running out of time
• Cultural fit matters more in Italian interviews than in US or UK processes. Prepare for relationship-building questions
• Salaries increased 8-12% in 2026 due to talent shortage. Candidates with both SQL and Python command premium offers

For additional interview preparation, the Data Analytics Interview Questions guide covers broader topics, and the SQL Window Functions article provides deeper SQL practice.