# Great Expectations 2026: Validasi Kualitas Data dan Pertanyaan Wawancara

> Panduan lengkap framework Great Expectations 1.22 untuk validasi kualitas data dalam pipeline Python, termasuk integrasi Airflow dan pertanyaan wawancara data engineering.

- Published: 2026-09-13
- Updated: 2026-09-13
- Author: Anthony Fillion-Maillet
- Tags: great-expectations, data-quality, python, airflow, data-engineering
- Reading time: 12 min

---

Great Expectations (GX) merupakan framework open-source standar untuk validasi kualitas data dalam pipeline data berbasis Python. Versi 1.22, yang dirilis pada Agustus 2026, memperkuat perubahan API yang diperkenalkan dalam GX 1.0 dan menambahkan dukungan eksperimental Python 3.14, menjadikannya alat penting bagi data engineer yang membangun pipeline tingkat produksi.

> **GX Core vs GX Cloud**
>
> GX Core adalah library open-source (lisensi Apache 2.0) dengan 11.400+ GitHub stars. GX Cloud adalah platform SaaS terkelola yang dibangun di atasnya, menawarkan alat kolaborasi dan dashboard monitoring real-time. Artikel ini berfokus pada GX Core.

## Masalah yang Dipecahkan Great Expectations dalam Pipeline Data

Pipeline data sering gagal secara diam-diam. Perubahan skema di upstream, nilai null yang seharusnya tidak ada, format tanggal yang berubah dari ISO ke Unix timestamp: masalah-masalah ini sering mencapai dashboard atau model ML sebelum ada yang menyadarinya. Great Expectations memperlakukan data seperti kode, menerapkan assertion (disebut Expectation) yang berjalan secara otomatis pada checkpoint dalam pipeline.

Framework ini terintegrasi dengan [Apache Airflow](/blog/data-engineering/apache-airflow-pipeline-orchestration-dags-interview-2026), Databricks, Snowflake, dan layanan cloud storage seperti AWS S3 dan Azure Blob Storage. Setiap validasi menghasilkan Data Docs, laporan HTML yang dapat dibaca oleh stakeholder non-teknis.

## Konsep Inti: Data Context, Data Sources, dan Expectations

GX 1.22 mengorganisir validasi di sekitar empat komponen: Data Context, Data Sources, Data Assets, dan Expectation Suites.

**Data Context** adalah objek konfigurasi pusat. Objek ini menyimpan metadata untuk Data Sources, Expectation Suites, Checkpoints, dan Validation Results historis. Pada kebanyakan proyek, satu direktori `gx/` menyimpan file konfigurasi YAML dan Data Docs yang dihasilkan.

**Data Source** merepresentasikan koneksi ke database, data warehouse, atau file system. **Data Asset** adalah kumpulan record logis dalam source tersebut, mirip dengan tabel atau result set dari query.

```python
# gx_setup.py
import great_expectations as gx

# Initialize or load an existing Data Context
context = gx.get_context()

# Add a Pandas Data Source for local files
data_source = context.data_sources.add_pandas("local_files")

# Define a Data Asset pointing to a specific CSV pattern
data_asset = data_source.add_csv_asset(
    name="user_events",
    filepath_or_buffer="data/user_events_*.csv"  # Glob pattern
)
```

Setup ini memungkinkan GX untuk memvalidasi CSV apapun yang cocok dengan `user_events_*.csv` di direktori `data/`.

## Membangun Expectation Suite untuk Validasi Kolom

Expectation Suite adalah kumpulan assertion terhadap Data Asset. Setiap Expectation mendeklarasikan kondisi yang harus benar untuk data, seperti "kolom `user_id` tidak boleh null" atau "kolom `age` harus berisi nilai antara 0 dan 120."

```python
# build_suite.py
import great_expectations as gx

context = gx.get_context()

# Create or retrieve an Expectation Suite
suite = context.suites.add(
    gx.ExpectationSuite(name="user_events_suite")
)

# Add Expectations to the suite
suite.add_expectation(
    gx.expectations.ExpectColumnToExist(column="user_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="user_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeBetween(
        column="age",
        min_value=0,
        max_value=120
    )
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToMatchRegex(
        column="email",
        regex=r"^[\w.-]+@[\w.-]+\.\w+$"
    )
)

# Save the suite to the Data Context
context.suites.save(suite)
```

GX 1.0+ menggunakan API berbasis class untuk Expectations. Sintaks berbasis dictionary yang lama (`expect_column_to_exist`) masih tersedia tetapi pendekatan berbasis class memberikan autocompletion IDE dan type safety yang lebih baik.

## Menjalankan Validasi dengan Checkpoints

Checkpoint menghubungkan Data Asset, Expectation Suite, dan Actions opsional yang dipicu ketika validasi berhasil atau gagal. Checkpoint adalah entry point utama untuk validasi otomatis dalam produksi.

```python
# run_checkpoint.py
import great_expectations as gx

context = gx.get_context()

# Create a Checkpoint
checkpoint = context.checkpoints.add(
    gx.Checkpoint(
        name="user_events_checkpoint",
        validation_definitions=[
            gx.ValidationDefinition(
                name="validate_user_events",
                data=context.data_sources.get("local_files")
                    .get_asset("user_events")
                    .build_batch_request(),
                suite=context.suites.get("user_events_suite")
            )
        ],
        actions=[
            gx.checkpoint.UpdateDataDocsAction(name="update_docs"),
        ]
    )
)

# Run the Checkpoint
result = checkpoint.run()

# Check overall success
if result.success:
    print("All validations passed")
else:
    print("Validation failures detected")
    for validation_result in result.run_results.values():
        for expectation_result in validation_result.results:
            if not expectation_result.success:
                print(f"  Failed: {expectation_result.expectation_config}")
```

Ketika Checkpoint berjalan, GX memuat batch, menerapkan setiap Expectation, dan memperbarui Data Docs. Validasi yang gagal dapat memicu notifikasi Slack, alert PagerDuty, atau penghentian pipeline tergantung pada Actions yang dikonfigurasi.

## Integrasi GX dengan Apache Airflow DAGs

Sebagian besar pipeline data produksi menggunakan orchestrator seperti Apache Airflow. GX menyediakan [integrasi Airflow resmi](https://docs.greatexpectations.io/docs/core/introduction/community_resources/#integrations) yang membungkus eksekusi Checkpoint dalam operator.

```python
# dags/user_events_pipeline.py
from airflow import DAG
from airflow.operators.python import PythonOperator
from datetime import datetime
import great_expectations as gx

def validate_user_events():
    """Run GX Checkpoint for user events data."""
    context = gx.get_context(context_root_dir="/opt/airflow/gx")
    checkpoint = context.checkpoints.get("user_events_checkpoint")
    result = checkpoint.run()
    
    if not result.success:
        # Raise exception to fail the Airflow task
        raise ValueError("Data validation failed. Check Data Docs for details.")

with DAG(
    dag_id="user_events_pipeline",
    start_date=datetime(2026, 1, 1),
    schedule_interval="@daily",
    catchup=False
) as dag:
    
    validate_task = PythonOperator(
        task_id="validate_user_events",
        python_callable=validate_user_events
    )
    
    # Downstream tasks depend on validation passing
    # transform_task >> load_task
```

Menempatkan validasi sebelum task transformasi mencegah data buruk menyebar ke downstream. Pola ini, kadang disebut "shift-left testing," menangkap masalah pada saat ingestion daripada setelah pekerjaan compute yang mahal selesai.

## Pertanyaan Wawancara Umum tentang Great Expectations

Wawancara data engineering di tahun 2026 sering menyertakan pertanyaan tentang tooling kualitas data. Berikut adalah pertanyaan yang muncul dalam technical screen, beserta jawaban yang membedakan kandidat berpengalaman dari junior.

### "Bagaimana cara mengimplementasikan data quality checks dalam pipeline produksi?"

Jawaban yang kuat menyebutkan embedding validasi sebagai tahap pipeline, bukan sebagai dashboard terpisah. Secara spesifik:

- Validasi skema pada saat ingestion menangkap masalah struktural dengan segera, misalnya string yang muncul di mana integer diharapkan
- Validasi business logic memeriksa constraint domain seperti harga positif dan rentang tanggal
- Alert otomatis memberitahu engineer on-call ketika validasi gagal, mencegah korupsi data diam-diam
- [dbt tests](/blog/data-engineering/dbt-data-transformations-testing-interview-2026) menangani pengecekan lapisan transformasi sementara GX menangani validasi ingestion dan output

### "Apa perbedaan antara Expectation Suite dan Checkpoint?"

Expectation Suite berisi assertion itu sendiri: kolom mana yang harus ada, rentang nilai apa yang dapat diterima, pola regex mana yang harus cocok. Ini mendefinisikan *apa* yang harus diperiksa.

Checkpoint mendefinisikan *kapan* dan *bagaimana* menjalankan pengecekan tersebut. Ini menghubungkan Data Asset spesifik (data yang akan divalidasi), Expectation Suite (aturan yang akan diterapkan), dan Actions (apa yang terjadi setelah validasi).

### "Bagaimana menangani Expectations yang bervariasi berdasarkan environment?"

Data produksi sering memiliki karakteristik berbeda dari data staging. Dua pendekatan:

1. **Parameterized Expectations**: Gunakan environment variables atau runtime parameters untuk menyesuaikan threshold. Misalnya, `min_value=int(os.getenv("AGE_MIN", 0))`.

2. **Multiple Suites**: Pertahankan suite terpisah untuk staging dan produksi. Staging mungkin mengizinkan null pada field opsional untuk menguji aliran data yang tidak lengkap.

### "Apa yang terjadi ketika Checkpoint gagal dalam pipeline terjadwal?"

Checkpoint mengembalikan `CheckpointResult` dengan `success=False`. Perilaku pipeline bergantung pada bagaimana orchestrator menangani kegagalan:

- Di Airflow, raising exception menandai task sebagai gagal, memblokir task downstream
- Di Databricks, notebook dapat keluar dengan status error
- Actions yang terpasang pada Checkpoint dapat mengirim pesan Slack, membuat tiket Jira, atau memicu prosedur rollback

## Custom Expectations untuk Validasi Domain-Spesifik

GX menyertakan 300+ Expectations bawaan, tetapi aturan domain-spesifik sering memerlukan implementasi kustom. Custom Expectation meng-extend base class dan mengimplementasikan logika validasi.

```python
# custom_expectations/expect_valid_iso_country_code.py
from great_expectations.expectations import Expectation
from great_expectations.core import ExpectationConfiguration
import pycountry

class ExpectValidIsoCountryCode(Expectation):
    """Expect column values to be valid ISO 3166-1 alpha-2 country codes."""
    
    column: str
    
    @classmethod
    def _prescriptive_template(cls) -> str:
        return "Column {column} values must be valid ISO country codes"
    
    def _validate(self, metrics, runtime_configuration=None, execution_engine=None):
        column_values = metrics.get("column_values")
        valid_codes = {c.alpha_2 for c in pycountry.countries}
        
        invalid_values = [
            v for v in column_values 
            if v is not None and v not in valid_codes
        ]
        
        return {
            "success": len(invalid_values) == 0,
            "result": {
                "observed_value": len(invalid_values),
                "unexpected_list": invalid_values[:10]  # Sample
            }
        }
```

Daftarkan Custom Expectations dengan menempatkannya di direktori `great_expectations/plugins/` atau menambahkan modul ke `plugins_directory` di `great_expectations.yml`.

## Data Docs: Mengkomunikasikan Kualitas kepada Stakeholder

Data Docs adalah situs HTML statis yang dihasilkan dari hasil validasi. Setiap eksekusi menghasilkan halaman yang menunjukkan Expectations mana yang lulus atau gagal, dengan detail drill-down pada nilai yang tidak diharapkan.

```python
# Generate and open Data Docs
context = gx.get_context()
context.build_data_docs()
context.open_data_docs()  # Opens browser
```

Untuk sistem produksi, Data Docs dapat di-host di S3, GCS, atau Azure Blob Storage dengan kontrol akses yang sesuai. [Platform GX Cloud](https://greatexpectations.io/) menawarkan Data Docs yang di-host dengan fitur kolaborasi tim.

## Migrasi GX 1.0: Breaking Changes dari 0.x

Tim yang meng-upgrade dari GX 0.x menghadapi perubahan API. Perbedaan utama:

| GX 0.x | GX 1.0+ |
|--------|--------|
| `context.create_expectation_suite()` | `context.suites.add()` |
| `context.add_datasource()` | `context.data_sources.add_*()` |
| Dictionary-based Expectations | Class-based Expectations |
| `context.run_checkpoint()` | `checkpoint.run()` |

[Panduan migrasi resmi](https://docs.greatexpectations.io/docs/core/introduction/gx_overview/) mencakup setiap perubahan. Untuk codebase besar, migrasi inkremental menggunakan compatibility shims mengurangi risiko.

## Poin-Poin Penting untuk Kualitas Data dengan GX 1.22

- Great Expectations 1.22 (Agustus 2026) mendukung Python 3.10 hingga 3.13, dengan dukungan eksperimental 3.14 melalui environment variable `GX_PYTHON_EXPERIMENTAL`
- Expectation Suites mendefinisikan *apa* yang harus divalidasi, Checkpoints mendefinisikan *kapan* dan *bagaimana*
- Embed Checkpoints sebagai tahap pipeline dalam [DAG Airflow](/blog/data-engineering/apache-airflow-pipeline-orchestration-dags-interview-2026) atau notebook Databricks untuk menangkap data buruk pada saat ingestion
- Custom Expectations menangani aturan domain-spesifik yang tidak dapat dicakup oleh Expectations bawaan
- Data Docs menyediakan laporan HTML yang dapat dibaca stakeholder; host di cloud storage untuk akses produksi
- Jawaban wawancara harus menekankan kualitas data sebagai tahap pipeline yang tertanam, bukan dashboard tambahan

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/id/blog/data-engineering/great-expectations-data-quality-validation-interview-2026