Build a Customer Churn Prediction Pipeline - Week of 12 Oct 2026

Problem definition

Input data (download): https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv

You are given a dataset of Titanic passenger records with columns including Survived, Pclass, Sex, Age, Fare, Embarked, and SibSp. Your task is to build a reproducible Python pipeline that loads this data, performs exploratory analysis, cleans and engineers features, trains a classification model, and evaluates its performance. The pipeline must use SQL for data queries, pandas for data manipulation, pytest for testing, and demonstrate professional version control practices. You will not build a web UI, deploy to production, or optimize for real-time inference; focus on code quality, reproducibility, and clear documentation of your modeling decisions. Every line under Success criteria is in scope for this challenge. Build the core scope in Task brief. Topic coverage uses repository evidence where available and the comprehension conversation; it does not require a separate feature for every topic.

Task brief

You will create a Python 3 project that demonstrates Version Control, SQL, Programming Fundamentals, Python Programming, Pandas, Data Cleaning & Preparation, Exploratory Data Analysis, Statistical Fundamentals, Data Visualization, and AI Assisted Software Development. Load the Titanic dataset, write SQL queries to explore passenger segments, perform data cleaning and feature engineering, create visualizations of survival patterns, train a scikit-learn classifier, and validate your model with pytest. Use a requirements.txt file to manage dependencies, commit your work to Git with clear messages, and leverage AI tools to accelerate development and code review.

Version Control

Version Control is essential for tracking changes to your Python pipeline code and enabling team collaboration. You will initialize a Git repository, commit your data loading, feature engineering, model training, and testing code at logical checkpoints, create branches for experimental features, and practice resolving merge conflicts when integrating changes. This ensures your manager and senior analysts can review your work, understand your modeling decisions, and extend the pipeline reliably.

SQL

SQL is used in the Titanic pipeline to query and aggregate passenger data for exploratory analysis and feature engineering. You will write SELECT, WHERE, GROUP BY, and JOIN queries to extract passenger subsets, compute survival statistics by demographic groups, and validate data quality before model training. These queries will be embedded in Python functions, tested with pytest, and documented in your Git repository.

Programming Fundamentals

Programming Fundamentals underpins the entire Titanic pipeline by requiring you to write clean, readable Python code that loads data, manipulates it with variables and collections, applies control flow logic for data cleaning, defines reusable functions for feature engineering, and handles errors gracefully when files or data are malformed. You will demonstrate these fundamentals through a working, tested pipeline that a senior analyst can easily review and extend.

Python Programming

Python Programming is the core language for building the Titanic passenger analysis pipeline. You will write Python 3 code to load CSV data, perform exploratory analysis, clean and engineer features, train a classification model, and evaluate results. Your code must be organized into modules, tested with pytest, and tracked in Git to demonstrate professional data engineering practices.

Pandas

Use pandas to load the Titanic dataset, perform exploratory analysis, and engineer features for the classification pipeline. Pandas is the core tool for data manipulation, cleaning, and transformation throughout the project; you will use Series and DataFrames to structure passenger records, filter subsets for analysis, and aggregate statistics by passenger groups.

Excel

Use Excel pivot tables and lookup functions to summarize and cross-reference passenger survival patterns in the Titanic dataset during exploratory analysis. These intermediate Excel skills will help you quickly validate data distributions and relationships before building your Python pipeline, ensuring you understand the underlying patterns that your model should capture.

Data Cleaning & Preparation

Data Cleaning & Preparation focuses on handling incomplete and anomalous data in the Titanic dataset pipeline. You will identify and treat missing values across passenger records and detect outliers in numerical features like Age and Fare, documenting your decisions so the model training step receives reliable, validated input.

Exploratory Data Analysis

Perform Exploratory Data Analysis on the Titanic passenger dataset to understand distributions, missing values, and relationships between features. Use pandas to profile the data and compute correlations, documenting your findings in a reproducible notebook or script that will inform feature engineering and model selection decisions.

Statistical Fundamentals

Statistical Fundamentals underpins the exploratory analysis phase of the Titanic pipeline. You will compute and interpret descriptive statistics—mean, median, standard deviation, distributions, and correlations—across passenger demographics and survival outcomes to inform feature engineering and model design decisions.

Data Visualization

Data Visualization transforms the cleaned Titanic dataset into clear, actionable charts and dashboards that reveal survival patterns by passenger class, age, and fare. As a junior data analyst, you will create visualizations using Power BI and Tableau to communicate key findings to stakeholders, ensuring your pipeline outputs are interpretable and support the historical analysis goals outlined by your manager.

Ai Assisted Software Development

AI Assisted Software Development teaches you to leverage AI tools to write, debug, test, and document your Titanic pipeline code faster while maintaining quality and understanding. You will use AI assistants to generate initial code for data loading and model training, validate and refactor their output, write unit tests with AI support, and document your modeling decisions—all while recognizing AI limitations and ensuring your final pipeline is reproducible and reviewable by your team.

Language and stack

Python 3, pytest, scikit-learn, pandas, matplotlib or seaborn, SQLite (or similar SQL interface), Git, and AI-assisted code generation tools.

Scenario

You are a junior data analyst at a maritime research firm. The team needs a repeatable pipeline to understand which passenger characteristics predicted survival on the Titanic, and to build a model that could inform historical analysis and educational materials. Your manager has given you one day to prototype a working model and document your approach. The code must be clean, testable, and easy for a senior analyst to review and extend. You will use Git to track your progress, pandas to wrangle the data, SQL to query passenger segments, and AI tools to help you write and review code faster.

Deliverables

1. A Python package with a main pipeline script that loads data, performs SQL-based exploration, cleans and engineers features, creates at least two visualizations of survival patterns, trains a model, and outputs evaluation metrics (accuracy, precision, recall, F1).
2. A pytest test suite covering data loading, data cleaning, feature engineering, and model training logic.
3. A requirements.txt file listing all dependencies and a README.md explaining how to run the pipeline, interpret results, and reproduce the analysis.

Success criteria

These are repository evidence checks within the core scope, not additional feature requests. One implementation or test may provide evidence for several topics. Missing implementation evidence remains unverified; explanations alone do not demonstrate implementation proficiency.

Version Control

• Repository Setup (beginner): Git repository initialized in the project root with a .gitignore file excluding pycache, .pytest_cache, *.pyc, and data downloads; verify via git log or .git directory presence.
• Basic Commands (beginner): At least three commits present in the repository history, each with a clear message describing a logical unit of work (e.g., initial setup, data loading, model training); verify via git log.
• Commits (beginner): Commits are atomic and focused on single concerns (e.g., one commit for data loading, one for feature engineering, one for model evaluation); verify by inspecting commit diffs and messages.
• Branching (beginner): At least one feature branch created and checked out (e.g., feature/model-tuning or feature/sql-queries); verify via git branch or git log --graph.
• Merging (beginner): Feature branch merged back to main or master with a merge commit or fast-forward; verify via git log and branch history.
• Conflict Resolution (intermediate): If merge conflicts occur in the learner repo during integration of branches, conflicts are resolved by editing the conflicted file, staging the resolution, and completing the merge; verify via git log and final file state.
• Pull Requests (intermediate): If using a platform like GitHub, a pull request is opened for a feature branch with a description of changes and rationale; verify via PR history or equivalent code review artifact in the repository.

SQL

• SELECT Queries (beginner): Repository contains at least one SELECT query (in SQL string or test fixture) that retrieves a specific passenger subset (e.g., by Pclass or Sex) with correct column projection and WHERE clause.
• JOINs (intermediate): inspect relevant code or tests within the core scope if present; do not add a feature solely for this topic. Missing implementation evidence remains unverified.
• GROUP BY (intermediate): Repository contains at least one GROUP BY query that aggregates survival counts or rates by a categorical column (Pclass, Sex, or Embarked) with correct COUNT or SUM function and produces expected output in test or pipeline log.
• SELECT, FROM, WHERE (intermediate): Repository shows at least one query combining SELECT, FROM, and WHERE clauses to filter passengers by a single condition (e.g., Age > 18 or Embarked = "S") with correct syntax and expected row count verified in test or pipeline log.
• GROUP BY, ORDER BY (intermediate): Repository shows at least one query using both GROUP BY and ORDER BY to rank passenger segments by survival rate or count in descending order, with results validated in a test assertion or pipeline output.
• Join S (INNER, LEFT) (intermediate): If multiple tables or derived views are present, repository shows at least one INNER or LEFT JOIN query combining passenger records with aggregated survival statistics; assess only if present in core scope.
• Aggregate Functions (COUNT, SUM, AVG) (intermediate): Repository contains queries using COUNT, SUM, or AVG functions to compute survival totals, passenger counts, or mean fare by group, with results logged or tested.
• Subqueries (beginner): If used in the pipeline, repository shows at least one subquery (e.g., filtering by above-average fare or selecting from a derived table) with correct nesting and expected output in test or log.
• Basic DDL/DML (beginner): Repository demonstrates CREATE TABLE or INSERT statements to load or initialize the Titanic dataset into a local database or in-memory table, with schema and row count verified in setup or test fixture.

Programming Fundamentals

• Variables & Data Types (beginner): Repository contains Python code that declares and uses variables of different types (int, float, str, bool, list, dict) to store passenger records, features, and model outputs; inspect variable assignments in data loading and feature engineering sections.
• Operators (beginner): Code uses arithmetic, comparison, and logical operators correctly in feature calculations (e.g., age bins, fare ratios, boolean masks for filtering); verify operator usage in pandas operations and conditional statements.
• Expressions (beginner): Code evaluates expressions to compute derived features or filter data (e.g., Age > 18, Fare / SibSp + 1); inspect expression results in test assertions or printed outputs.
• Control Flow (beginner): Implementation includes if/elif/else blocks and loops (for or while) for data iteration, conditional cleaning, or model evaluation; verify control flow in data pipeline or test files.
• Functions & Methods (beginner): Code defines at least one custom function (e.g., load_data, clean_features, evaluate_model) and calls built-in methods (e.g., pandas .fillna(), .groupby(), .apply()); inspect function definitions and method calls in the pipeline.
• Collections (intermediate): Code uses lists, dictionaries, and pandas Series/DataFrames to store and manipulate multiple passenger records; verify collection operations (indexing, slicing, iteration, aggregation) in data loading and feature engineering.
• Exception Handling (intermediate): Code includes try/except blocks to handle file not found, missing values, or type errors during data loading or processing; verify exception handling in critical sections (e.g., CSV read, data validation).
• File Handling (beginner): Code opens, reads, and processes the Titanic CSV file; verify file I/O in the data loading function or test setup.

Python Programming

• Python Syntax (beginner): Repository contains executable Python 3 scripts (.py files) that load the Titanic CSV, perform data operations without syntax errors, and run to completion.
• Functions (beginner): Code includes at least two reusable functions (e.g., data loading, feature engineering, model evaluation) that accept parameters and return results; pytest tests call these functions with different inputs.
• Modules & Packages (beginner): Code is organized into separate .py files (e.g., data_loader.py, model.py, evaluate.py) and imports are used correctly; main script imports and calls functions from these modules.
• Virtual Environments (beginner): Repository includes requirements.txt or pyproject.toml listing dependencies (pandas, scikit-learn, pytest); evidence of virtual environment use in commit history or setup documentation.
• Object-Oriented Python (intermediate): Pipeline includes at least one class (e.g., TitanicPipeline, DataProcessor, or ModelEvaluator) with init, at least two methods, and correct instantiation in the main workflow; pytest tests verify class behavior and state changes.

Pandas

• Series & DataFrames (beginner): Repository contains a pandas DataFrame loaded from the Titanic CSV with at least Survived, Pclass, Sex, Age, Fare, Embarked, and SibSp columns; inspect the loaded structure and shape in code or test output.
• Filtering (intermediate): Repository contains code that filters the DataFrame by at least one condition (e.g., passengers by class, sex, or age range) and produces a subset; verify the filter logic in implementation or test assertions.
• GroupBy (intermediate): Repository contains a groupby operation that aggregates passenger data by at least one column (e.g., survival rate by Pclass or Sex) and produces a summary; verify the groupby result in code or test output.

Excel

• Pivot Tables (intermediate): Create and save at least one pivot table in the learner repo (e.g., survival rate by passenger class and sex) that demonstrates row/column grouping, aggregation (count or sum), and filtering; verify the pivot table output matches expected survival breakdowns from the raw CSV.
• Lookup Functions (intermediate): Implement at least one VLOOKUP or INDEX/MATCH formula in the same workbook to cross-reference passenger fare or age data against a reference table or summary; confirm the formula returns correct values for at least three test cases.

Data Cleaning & Preparation

• Missing Values (intermediate): Repository contains pandas code that identifies missing values in the dataset (e.g., using isnull() or info()), applies a documented imputation or removal strategy (e.g., forward fill, mean imputation, or row deletion), and produces a cleaned dataset passed to downstream analysis or modeling steps.
• Outlier Detection (intermediate): Repository contains code that detects outliers in numerical columns (Age, Fare, SibSp) using a defined method (e.g., IQR, z-score, or domain thresholds), logs or flags detected outliers, and either removes or transforms them with justification documented in comments or a test assertion.

Exploratory Data Analysis

• Data Profiling (intermediate): Load the Titanic CSV and generate summary statistics (count, mean, std, min, max, quartiles) for numeric columns and value counts for categorical columns using pandas describe() and value_counts(); document missing value counts per column and identify data types.
• Correlation Analysis (intermediate): Compute Pearson correlation coefficients between numeric features and the Survived target using pandas corr() or numpy; visualize or tabulate the top correlations and explain which features show strongest association with survival.

Statistical Fundamentals

• Descriptive Statistics (intermediate): Repository contains Python code (in Jupyter notebook, script, or test fixture) that computes and displays summary statistics (mean, median, std, min, max, quartiles) for numeric columns (Age, Fare, SibSp) and frequency counts for categorical columns (Survived, Pclass, Sex, Embarked) using pandas describe(), value_counts(), or equivalent methods; output is visible in committed notebook cells, script output, or test assertions.

Data Visualization

• Power BI Fundamentals (intermediate): Create at least one interactive Power BI report or dashboard connected to the cleaned Titanic dataset, showing survival rates segmented by Pclass, Sex, or Age; verify the visualization updates when underlying data changes and includes at least one filter or slicer control.
• Tableau Fundamentals (intermediate): Build at least one Tableau worksheet or dashboard from the Titanic dataset displaying survival distribution across a key demographic variable; confirm the visualization renders correctly and includes a title, axis labels, and a legend or color encoding that clarifies the data mapping.

Ai Assisted Software Development

• Working with AI Assistants (beginner): Repository contains at least one Python module (e.g., data_loader.py, model.py) with a commit message or code comment indicating AI-assisted generation; the code runs without errors and integrates into the pipeline.
• Prompt Writing Fundamentals (beginner): Commit history or inline comments show evidence of iterative prompts to AI (e.g., "refined prompt to specify pandas DataFrame output" or "asked AI to add error handling"); at least one prompt refinement is documented.
• Code Generation (beginner): AI-generated code for data loading, feature engineering, or model training is present in the repository and executes successfully as part of the pipeline.
• AI-assisted Debugging (beginner): At least one bug fix or error resolution is documented in a commit message or code comment referencing AI assistance (e.g., "fixed KeyError with AI suggestion"); the fix is applied and tests pass.
• AI-assisted Refactoring (intermediate): A refactored function or module shows improved readability, reduced duplication, or better structure; commit message or comment indicates AI-assisted refactoring; original and refactored versions are both testable.
• AI-assisted Unit Testing (intermediate): pytest test file contains at least two test functions with evidence of AI assistance (e.g., commit message "AI-generated test cases for data validation"); tests execute and pass.
• AI-assisted Documentation (beginner): Docstrings, README section, or inline comments are present and indicate AI assistance; documentation accurately describes function behavior or pipeline steps.
• AI Output Validation (intermediate): Code review comment, commit message, or test assertion shows the learner validated AI output (e.g., "verified AI-generated SQL query returns correct row count"); validation is observable in tests or manual checks.
• Responsible AI Usage (beginner): Commit message, code comment, or documentation note acknowledges a limitation or hallucination caught during development (e.g., "AI suggested incorrect column name; corrected to match actual data").

What to explain

AI assistance is allowed while building the submission. During the comprehension conversation, answer independently without AI tools, search, or outside help. Be ready to trace your actual code, explain decisions and limitations, and reason about a small change or failure case. Conceptual topics do not require a separate coded feature.

Version Control

• Repository Setup (beginner): Explain why a .gitignore file is necessary and what files or directories should be excluded from version control in a Python data project.
• Basic Commands (beginner): Describe the purpose of git add, git commit, and git log, and explain how you used them to track your pipeline development.
• Commits (beginner): Explain the principle of atomic commits and give an example of a good commit message from your pipeline work.
• Branching (beginner): Describe why you created a feature branch and what work you isolated on it; explain how branching supports parallel development or experimentation.
• Merging (beginner): Explain the difference between a merge commit and a fast-forward merge, and describe which occurred when you merged your feature branch.
• Conflict Resolution (intermediate): If conflicts arose, explain what caused them, how you identified the conflicting sections, and how you decided which changes to keep; if no conflicts occurred, describe a realistic scenario in which two branches modifying the same function would conflict and how you would resolve it.
• Pull Requests (intermediate): Explain the purpose of a pull request in a team setting, describe what information your PR included, and discuss how code review via PR improves code quality and knowledge sharing.

SQL

• SELECT Queries (beginner): Explain why you chose specific columns in your SELECT query and how the WHERE clause filters the passenger dataset for your analysis.
• JOINs (intermediate): Describe the relationship between tables or views in your pipeline and justify your choice of INNER or LEFT JOIN to combine passenger and aggregation data.
• GROUP BY (intermediate): Explain how GROUP BY segments passengers by a demographic column and why COUNT or SUM is the appropriate aggregate function for your survival analysis.
• SELECT, FROM, WHERE (intermediate): Trace through a query execution: given the Titanic data, predict the row count and column values returned by a specific SELECT...FROM...WHERE statement and explain the filtering logic.
• GROUP BY, ORDER BY (intermediate): Reason about the effect of ORDER BY on grouped results: which segments appear first, and how does sort order support your exploratory findings?
• Join S (INNER, LEFT) (intermediate): Compare INNER and LEFT JOIN outcomes on passenger and survival statistics: which rows are retained or dropped, and when would you choose each join type?
• Aggregate Functions (COUNT, SUM, AVG) (intermediate): Given a GROUP BY query, predict the aggregate values (e.g., survival count per class) and explain how each function contributes to your feature engineering or validation.
• Subqueries (beginner): Explain the purpose of a subquery in your pipeline (e.g., filtering by derived statistics) and how it simplifies or clarifies your data extraction logic.
• Basic DDL/DML (beginner): Describe the schema you created or used to load the Titanic dataset and justify your choice of data types and constraints for key columns.

Programming Fundamentals

• Variables & Data Types (beginner): Explain why you chose specific data types (e.g., int for Pclass, float for Age, str for Sex) and how type mismatches could break your pipeline.
• Operators (beginner): Describe how you used comparison operators to filter passengers (e.g., Age > 18) and logical operators to combine conditions (e.g., Sex == "male" AND Pclass == 1).
• Expressions (beginner): Walk through one derived feature expression (e.g., Age / (SibSp + 1)) and explain what it computes and why.
• Control Flow (beginner): Trace through a loop or conditional block in your data cleaning code and explain how it handles different passenger records or missing values.
• Functions & Methods (beginner): Explain why you defined a custom function (e.g., load_data) instead of writing the code inline, and describe one pandas method you used and what it does.
• Collections (intermediate): Describe how you used a list or dictionary to organize passenger data or model results, and explain why that structure was better than storing individual variables.
• Exception Handling (intermediate): Identify one error that could occur in your pipeline (e.g., missing CSV file, NaN in Age column) and explain how your try/except block prevents the pipeline from crashing.
• File Handling (beginner): Explain how your code reads the CSV file and what would happen if the file path were incorrect or the file did not exist.

Python Programming

• Python Syntax (beginner): Explain one syntax choice in the code (e.g., list comprehension vs. loop, f-string formatting) and why it was appropriate for this task.
• Functions (beginner): Describe the parameters and return values of one function; explain how breaking this logic into a function improved code reusability or testability.
• Modules & Packages (beginner): Walk through the import statements in the main script; explain why separating data loading, modeling, and evaluation into different modules makes the pipeline easier to maintain.
• Virtual Environments (beginner): Explain what a virtual environment is and why it matters for this project; describe how you created or activated it.
• Object-Oriented Python (intermediate): Describe the class you designed, its attributes, and at least two methods; explain how encapsulation (grouping data and behavior) made the pipeline clearer or easier to test compared to a purely functional approach.

Pandas

• Series & DataFrames (beginner): Explain the difference between a Series and a DataFrame and why the Titanic dataset is structured as a DataFrame rather than separate Series.
• Filtering (intermediate): Describe the filtering logic used in your code (e.g., boolean indexing or query method) and explain why that approach was chosen for the passenger subset you needed.
• GroupBy (intermediate): Walk through your groupby aggregation step-by-step: which column did you group by, what aggregation function did you apply, and what insight about survival patterns did the result reveal?

Excel

• Pivot Tables (intermediate): Explain how the pivot table structure (rows, columns, values) reveals survival patterns by passenger class and sex, and describe one insight from the pivot that informed your feature engineering or model design choices.
• Lookup Functions (intermediate): Walk through the logic of your lookup formula (e.g., why you chose VLOOKUP over INDEX/MATCH, how the range and column index work), and predict what would happen if the reference table were sorted differently or contained duplicate keys.

Data Cleaning & Preparation

• Missing Values (intermediate): Explain why the chosen imputation or removal strategy was selected for the Titanic dataset (e.g., why mean imputation suits Age but deletion suits Embarked), and describe how you verified the cleaned data does not introduce bias or loss of information critical to survival prediction.
• Outlier Detection (intermediate): Describe the outlier detection method you applied, justify why it is appropriate for Titanic passenger data, and explain how you decided whether to remove, cap, or retain flagged outliers and what impact that choice has on model fairness and accuracy.

Exploratory Data Analysis

• Data Profiling (intermediate): Explain what the summary statistics reveal about passenger age, fare, and class distributions; describe how missing values in Age and Embarked columns might affect downstream analysis and what imputation strategy you would consider.
• Correlation Analysis (intermediate): Interpret the correlation values you computed; discuss why Pclass and Sex show different correlation strengths with Survived, and how you would use these insights to prioritize features for the classification model.

Statistical Fundamentals

• Descriptive Statistics (intermediate): Learner explains why specific summary statistics (e.g., median vs. mean for Age, distribution shape for Fare) were chosen to understand passenger segments, identifies at least one data quality issue (e.g., missing Age values, outliers in Fare) revealed by descriptive analysis, and describes how these insights guided feature engineering or model input decisions in the pipeline.

Data Visualization

• Power BI Fundamentals (intermediate): Explain how you chose the chart type (e.g., bar, pie, scatter) for your Power BI visualization and why it effectively communicates survival patterns; describe one design decision (e.g., color scheme, drill-down hierarchy, or measure aggregation) and its impact on stakeholder understanding.
• Tableau Fundamentals (intermediate): Walk through your Tableau worksheet design: what data fields did you map to rows, columns, and marks, and how does this layout reveal survival trends; discuss one limitation of your current visualization and how you would refine it for a senior analyst review.

Ai Assisted Software Development

• Working with AI Assistants (beginner): Explain one way you used an AI tool to accelerate development of your pipeline and one limitation you encountered.
• Prompt Writing Fundamentals (beginner): Describe how you refined a prompt to the AI to get better code output; what detail did you add or change?
• Code Generation (beginner): Show one piece of AI-generated code in your pipeline and explain whether you modified it before committing; why or why not?
• AI-assisted Debugging (beginner): Walk through one error you encountered and how the AI helped you fix it; did you accept the suggestion as-is or adapt it?
• AI-assisted Refactoring (intermediate): Compare the original and refactored code; explain what improved and how the AI suggestion addressed a specific issue.
• AI-assisted Unit Testing (intermediate): Review one AI-generated test case; does it correctly validate the function behavior, and did you add or remove any assertions?
• AI-assisted Documentation (beginner): Read one docstring or README section the AI helped write; is it accurate and clear for a senior analyst reviewing your code?
• AI Output Validation (intermediate): Describe how you verified that AI-generated code (e.g., SQL query, pandas transformation) produces correct results; what checks did you run?
• AI Limitations & Hallucinations (beginner): Give one example of incorrect or misleading output from the AI during this project; how did you catch and correct it?
• Responsible AI Usage (beginner): Explain one practice you followed to ensure your AI-assisted code is trustworthy and maintainable for your team.

How to submit

1. Before you start, register on SahkaarX and connect your GitHub account via the app.
2. When the challenge begins, SahkaarX will create a private GitHub repository under your account and notify you in the app with a clone URL.
3. Clone the repository, implement your pipeline code, write tests, and commit your work with clear Git messages as you progress.
4. Push all commits to the repository and submit your work in the app by clicking the submit button; do not create your own separate GitHub repository.

What happens after you submit

After the challenge window closes, an automated AI system will analyze your repository for code quality, test coverage, and adherence to the skill topics. You will then be invited to a mandatory in-app conversation where you will discuss your pipeline design, modeling choices, data cleaning decisions, and code structure. This conversation verifies that you understand your own work and is not a written quiz; stay on the comprehension page and be ready to explain your decisions. Human judges will review your repo score and conversation transcript before final results are published.

Intellectual property

You retain full ownership of the code and analysis in your submission. SahkaarX may host, evaluate, and display your work on leaderboards and in challenge galleries. Your GitHub repository remains private under your account; you control access and can reuse the code for your portfolio or future projects after the challenge ends.