Active
Titanic Passenger Survival Prediction Pipeline - Week of 09 Nov 2026
This challenge has ended. You can still review the details below.
Explore the latest challenge for this roleBuild an end-to-end machine learning pipeline in Python to predict passenger survival on the Titanic using data cleaning, exploratory analysis, feature engineering, and model evaluation. Your submission will be evaluated by automated repo review when the challenge window closes, followed by a mandatory in-app conversation to verify your understanding.
Data Scientist
Solo only.
Share this challenge

The Challenge Brief
Problem definition
Input data (download): https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv
You are given a dataset of Titanic passengers with columns including Survived, Pclass, Sex, Age, Fare, Embarked, and SibSp. The task is to build a predictive model that estimates whether a passenger survived based on available features. Your pipeline must handle missing values, engineer meaningful features, train a classifier, and evaluate performance using appropriate metrics. 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
Build a complete machine learning workflow covering Version Control, SQL, Python Programming, Pandas, Data Cleaning & Preprocessing, Exploratory Data Analysis, Statistical Fundamentals, Data Visualization, Feature Engineering, Machine Learning, and Model Evaluation. Load the Titanic CSV, clean and preprocess the data (handle missing values, encode categorical features), perform exploratory analysis with visualizations, engineer at least two new features, train a logistic regression or tree-based classifier, evaluate using accuracy, precision, recall, and F1-score, and document your reasoning in code comments and a brief README. Expected effort: 6–8 hours with AI assistance.
Version Control
Show understanding of Version Control in this product.
SQL
Show understanding of SQL in this product.
Python Programming
Python Programming enables you to build a reproducible machine learning pipeline for the Titanic survival prediction task. You will write clean, modular code using functions, classes, and proper error handling to load data, engineer features, train a classifier, and evaluate results. Your implementation must follow Python best practices including virtual environment setup, type hints, and code organization suitable for peer review.
Pandas
Use Pandas to load the Titanic dataset, clean missing values, and prepare features for modeling. Apply GroupBy operations to aggregate passenger statistics by demographic groups, and use Merge operations to combine engineered features with the original data. This skill underpins the data preparation phase of the survival prediction pipeline.
Data Cleaning & Preprocessing
Data Cleaning & Preprocessing prepares the Titanic dataset for modeling by handling missing values, detecting and treating outliers, and scaling features appropriately. You will implement a reproducible preprocessing pipeline in Python that transforms raw passenger data into a clean, normalized feature set ready for classifier training.
Exploratory Data Analysis
Perform Exploratory Data Analysis on the Titanic dataset to understand feature distributions, missing values, and relationships before model development. This skill focuses on profiling the data, scaling numeric features appropriately, analyzing correlations with survival outcomes, and extracting actionable business insights that inform feature engineering and model selection.
Statistical Fundamentals
Statistical Fundamentals underpins the entire Titanic survival prediction pipeline. You will apply descriptive statistics to summarize passenger demographics, use probability concepts to model survival likelihood, and employ hypothesis testing to validate assumptions about risk factors. These statistical foundations ensure your model is interpretable and your conclusions are defensible.
Data Visualization
Data Visualization is essential for communicating insights from the Titanic survival model to stakeholders and the peer review team. You will create publication-ready plots using Matplotlib and Seaborn to explore passenger demographics, survival patterns, and feature relationships, embedding these visualizations in a Jupyter notebook or Python script that documents your exploratory data analysis and model evaluation.
Feature Engineering
Feature Engineering is the process of selecting, transforming, and creating features to improve model predictive power. In this Titanic survival prediction pipeline, you will identify which passenger attributes are most informative, encode categorical variables (Sex, Embarked, Pclass) into numeric form, and handle missing values strategically to prepare clean, meaningful input for your classifier.
Machine Learning
Machine Learning involves building and evaluating predictive models on the Titanic dataset. You will implement classification algorithms, handle missing data, engineer features, and assess model performance using appropriate metrics to predict passenger survival outcomes.
Model Evaluation
Model Evaluation focuses on assessing classifier performance on the Titanic survival prediction task using appropriate metrics and validation techniques. You will implement cross-validation to estimate generalization error, compute a confusion matrix to understand prediction patterns, and calculate precision, recall, and F1-score to evaluate class-specific performance. These evaluation practices ensure your model is robust and ready for peer review.
Language and stack
Python 3, pytest, pandas, scikit-learn, matplotlib or seaborn, git.
Scenario
You are a junior data scientist at a maritime research firm. Your team needs a reproducible pipeline to predict survival outcomes for historical passenger data. The model will inform a report on passenger demographics and risk factors. Your code must be clean, version-controlled, and ready for peer review within one day.
Deliverables
- A Python package or script that loads, cleans, and preprocesses the Titanic CSV; performs EDA with at least three visualizations; engineers features; trains and evaluates a classifier; and logs results to stdout or a CSV file.
- A pytest test suite with at least three tests covering data loading, preprocessing, and model output shape or type.
- A README documenting your approach, feature engineering choices, model selection rationale, and final performance metrics.
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): demonstrate Repository Setup for this product in the repository.
- Basic Commands (beginner): demonstrate Basic Commands for this product in the repository.
- Commits (beginner): demonstrate Commits for this product in the repository.
- Branching (beginner): demonstrate Branching for this product in the repository.
- Merging (beginner): demonstrate Merging for this product in the repository.
- Conflict Resolution (intermediate): demonstrate Conflict Resolution for this product in the repository.
- Pull Requests (intermediate): demonstrate Pull Requests for this product in the repository.
SQL
- SELECT Queries (beginner): demonstrate SELECT Queries for this product in the repository.
- JOINs (intermediate): demonstrate JOINs for this product in the repository.
- GROUP BY (intermediate): demonstrate GROUP BY for this product in the repository.
- Basic SQL Queries (intermediate): demonstrate Basic SQL Queries for this product in the repository.
- SQL Join S (intermediate): demonstrate SQL Join S for this product in the repository.
- Aggregation & Grouping (intermediate): demonstrate Aggregation & Grouping for this product in the repository.
- Basic Subqueries & Cte S (beginner): demonstrate Basic Subqueries & Cte S for this product in the repository.
Python Programming
- Virtual Environments (beginner): Repository contains a requirements.txt or pyproject.toml file listing all dependencies (pandas, scikit-learn, numpy, etc.) and evidence that the learner created and activated a virtual environment before installing packages.
- Functions & Modules (intermediate): Core pipeline logic is organized into reusable functions (e.g., load_data, preprocess_features, train_model, evaluate_model) with clear input/output behavior; functions are called consistently throughout the notebook or script.
- Object-Oriented Programming (intermediate): At least one custom class (e.g., TitanicPredictor or FeatureEngineer) is implemented with init, at least one method, and is instantiated and used in the pipeline.
- Type Hints (intermediate): Function signatures include type annotations for parameters and return values (e.g., def load_data(filepath: str) -> pd.DataFrame:); type hints are present in at least 70% of user-defined functions.
- Python Syntax & Data Structures (intermediate): Code demonstrates correct use of lists, dictionaries, pandas DataFrames, and control flow (loops, conditionals) to handle missing values, feature engineering, and model evaluation.
- Basic OOP Concepts (beginner): 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.
- Error Handling & Debugging (intermediate): Code includes try-except blocks or conditional checks for common failures (missing files, missing columns, invalid data types); error messages are informative and execution does not crash on malformed input.
Pandas
- GroupBy (intermediate): Repository contains code that groups passengers by at least two dimensions (e.g., Pclass and Sex) and computes aggregations (mean, count, or sum) on numeric columns such as Age or Fare; output is used or validated in the pipeline.
- Merge & Join (intermediate): Repository contains code that joins or merges at least one engineered feature DataFrame back to the main dataset using a key or index; the merged result is passed to the model training step.
Data Cleaning & Preprocessing
- Missing Values (intermediate): Repository contains code that identifies missing values in Age, Embarked, or Cabin columns and applies a documented strategy (e.g., mean imputation, forward fill, or removal); verify the strategy is applied consistently and the resulting dataset has no NaN values in the modeling feature set.
- Outlier Detection (intermediate): Repository contains code that detects outliers in Fare or Age using a method such as IQR, z-score, or isolation forest; document the detection logic and show that outliers are either flagged, removed, or transformed; verify the decision is justified in comments or a preprocessing notebook.
- Scaling & Normalization (intermediate): Repository contains code that applies scaling (StandardScaler, MinMaxScaler, or equivalent) to numeric features before model training; verify the scaler is fit on training data only and applied consistently to test data.
Exploratory Data Analysis
- Scaling & Normalization (intermediate): Repository contains code that identifies numeric columns (Age, Fare, SibSp) and applies a scaling or normalization technique (StandardScaler, MinMaxScaler, or equivalent); verify the transformation is applied and output shape matches input shape.
- Data Profiling (intermediate): Repository contains code that computes and displays summary statistics (mean, median, std, min, max, missing counts) for all columns; output shows at least one missing value count and one descriptive statistic per numeric column.
- Correlation Analysis (intermediate): Repository contains code that computes correlation coefficients between numeric features and the Survived target; output includes a correlation matrix or pairwise correlations showing at least three feature-target relationships.
- Business Insights (intermediate): Repository contains a summary or visualization (plot, table, or markdown) that identifies at least two passenger demographic patterns or risk factors (e.g., survival rate by Pclass, Sex, or Age group) derived from the profiling and correlation analysis.
Statistical Fundamentals
- Descriptive Statistics (intermediate): Repository contains code that computes and reports mean, median, standard deviation, and distribution summaries (e.g., via pandas describe() or numpy functions) for numeric features (Age, Fare, SibSp) and categorical counts (Sex, Pclass, Embarked) in the data exploration phase; output is visible in notebook or script logs.
- Probability (intermediate): Repository contains code that calculates conditional probabilities or class distributions (e.g., survival rate by Pclass or Sex using value_counts() or crosstab()) and uses these estimates to inform feature engineering or model initialization; probabilities are logged or visualized.
- Hypothesis Testing (intermediate): Repository contains code that performs at least one statistical test (e.g., chi-square for categorical association, t-test for Age difference between survivors and non-survivors, or correlation test) to validate a hypothesis about a feature and survival; test results (p-value, statistic) are reported and interpreted in comments or output.
Data Visualization
- Matplotlib (intermediate): Repository contains at least two distinct plot types (e.g., histogram, scatter, line plot) created with Matplotlib functions (pyplot or object-oriented API) that visualize passenger features or model predictions; plots have labeled axes, titles, and are saved or displayed in the notebook.
- Seaborn (intermediate): Repository contains at least one Seaborn plot (e.g., heatmap, boxplot, countplot, pairplot) that reveals relationships between survival outcome and passenger attributes; the plot uses Seaborn styling or palette parameters and is integrated into the analysis notebook.
Feature Engineering
- Feature Selection (intermediate): Repository contains code that filters or ranks features by relevance (e.g., correlation analysis, mutual information, or domain reasoning) and justifies which columns are retained or dropped before model training; evidence must show explicit feature subset selection logic applied to the input dataset.
- Feature Encoding (intermediate): Repository contains code that transforms categorical columns (Sex, Embarked, Pclass) into numeric representations (one-hot encoding, label encoding, or ordinal encoding) and handles missing Age or Fare values (imputation or removal); the encoded dataset is passed to the classifier without errors.
Machine Learning
- Linear Regression (intermediate): Repository contains a fitted linear regression model (e.g., via scikit-learn) applied to a numeric target or engineered feature; inspect model coefficients or predictions in code or test output.
- Logistic Regression (intermediate): Repository contains a trained logistic regression classifier with probability predictions on the Titanic survival task; verify via model.predict_proba() or decision boundary visualization in notebook or test.
- Decision Trees (intermediate): Repository contains a trained decision tree classifier with depth and feature importance inspection; confirm via tree depth, feature_importances_ attribute, or tree visualization artifact.
- Random Forest (intermediate): Repository contains a trained random forest classifier with ensemble predictions and feature importance ranking; verify via model.feature_importances_ and out-of-bag or cross-validation score in code.
- K-Means Clustering (intermediate): If present in repository, confirm k-means model fitted on engineered features with cluster assignments and inertia; assess only if implemented, not required for core survival prediction task.
Model Evaluation
- Cross Validation (intermediate): Repository contains code that splits the training data using k-fold cross-validation (k≥3) and reports mean and standard deviation of a performance metric across folds; observable in a script or notebook cell.
- Confusion Matrix (intermediate): Repository contains code that generates and displays a confusion matrix for the trained classifier on a held-out test set or cross-validation fold; true positives, true negatives, false positives, and false negatives are computed or printed.
- Precision Recall F1 (intermediate): Repository contains code that calculates and reports precision, recall, and F1-score for the binary survival classification task; values are printed, logged, or stored in the model evaluation output.
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
- Branching: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
- Merging: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
- Conflict Resolution: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
- Pull Requests: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
SQL
- SELECT Queries: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
- JOINs: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
- GROUP BY: explain the concept, relevant constraints, and tradeoffs in this product with a concrete example.
Python Programming
- Virtual Environments (beginner): Explain why isolating dependencies in a virtual environment prevents conflicts and improves reproducibility across team members.
- Functions & Modules (intermediate): Walk through one pipeline function and explain how its inputs, logic, and outputs support the overall workflow; discuss how modularization aids testing and peer review.
- Object-Oriented Programming (intermediate): Describe the purpose of your custom class, what state it maintains, and how its methods encapsulate related behavior; justify why a class was appropriate for this task.
- Type Hints (intermediate): Show an example of a type-hinted function from your code and explain how the annotations clarify expected data types and catch potential bugs during development.
- Python Syntax & Data Structures (intermediate): Trace through your handling of missing values or feature engineering using specific data structure operations (e.g., fillna, groupby, apply) and explain why you chose those methods.
- Basic OOP Concepts (beginner): Explain the difference between a class and an instance; describe one attribute and one method in your custom class and their roles.
- Error Handling & Debugging (intermediate): Show one try-except block or validation check in your code and explain what error it guards against and how the exception message helps diagnose the problem.
Pandas
- GroupBy (intermediate): Explain why grouping by Pclass and Sex reveals survival patterns; describe how the aggregation results inform feature engineering or model interpretation.
- Merge & Join (intermediate): Describe the join key and why that choice preserves data integrity; explain how merging engineered features back to the original dataset avoids data leakage or index misalignment.
Data Cleaning & Preprocessing
- Missing Values (intermediate): Explain why the chosen imputation strategy (mean, median, removal, or forward fill) is appropriate for Age and Embarked columns given the data distribution and the modeling task; discuss trade-offs between bias and data loss.
- Outlier Detection (intermediate): Describe the outlier detection method used, justify why it was chosen over alternatives, and explain how the detected outliers were handled; discuss whether removal or transformation was more appropriate for the Titanic survival prediction context.
- Scaling & Normalization (intermediate): Explain why scaling was necessary for the chosen features, describe the scaling method applied, and discuss why the scaler was fit on training data only; predict how omitting this step would affect model performance.
Exploratory Data Analysis
- Scaling & Normalization (intermediate): Explain why scaling is necessary for the Titanic dataset and which features benefit most; discuss the choice between StandardScaler and MinMaxScaler in the context of downstream model training.
- Data Profiling (intermediate): Describe the missing value patterns observed (e.g., Age and Embarked columns) and propose a strategy to handle them; justify why profiling is a prerequisite to feature engineering.
- Correlation Analysis (intermediate): Interpret the correlation coefficients between at least two features and Survived; explain which relationships are strongest and why they may be predictive.
- Business Insights (intermediate): Articulate one actionable insight from the EDA (e.g., female passengers had higher survival rates, or first-class passengers survived more often) and explain how it informs the modeling approach or feature selection.
Statistical Fundamentals
- Descriptive Statistics (intermediate): Explain how the computed summary statistics (mean, variance, skewness) of Age and Fare informed your choice of imputation strategy or feature scaling; discuss why median might be preferred over mean for Fare given potential outliers.
- Probability (intermediate): Describe how you estimated the prior probability of survival and how conditional probabilities (e.g., P(Survived|Female)) influenced your model design or feature weighting; justify your choice of probability model or assumption.
- Hypothesis Testing (intermediate): Interpret the p-value and conclusion of your chosen test; explain whether the result supports or refutes your hypothesis about the feature and survival, and how this finding shaped your feature selection or engineering decisions.
Data Visualization
- Matplotlib (intermediate): Explain why you chose specific plot types (histogram vs. boxplot vs. scatter) for different features; describe how you configured figure size, colors, or annotations to improve readability for a peer review audience.
- Seaborn (intermediate): Describe how your Seaborn visualization reveals a pattern or relationship relevant to survival prediction; justify your choice of hue, palette, or plot type and how it complements or differs from a raw Matplotlib equivalent.
Feature Engineering
- Feature Selection (intermediate): Explain why you chose specific features over others (e.g., correlation with Survived, domain knowledge about maritime survival factors, or statistical tests); discuss trade-offs between model complexity and interpretability when deciding feature count.
- Feature Encoding (intermediate): Describe your choice of encoding method for each categorical variable and justify why it suits the classifier you selected; explain how you handled missing values and whether your approach preserves or loses information.
Machine Learning
- Linear Regression (intermediate): Explain why linear regression is less suitable for binary classification (survival yes/no) compared to logistic regression, and describe how you would interpret coefficients in the context of passenger features.
- Logistic Regression (intermediate): Describe the sigmoid function and how logistic regression produces probability estimates; explain how you chose the decision threshold and how it affects precision vs. recall on the Titanic dataset.
- Decision Trees (intermediate): Explain how the tree selects split features and thresholds; discuss overfitting risk and how you would control tree depth or use pruning to improve generalization.
- Random Forest (intermediate): Explain how random forest reduces variance through ensemble averaging and feature randomness; compare its feature importance ranking to a single decision tree and discuss why ensemble methods often outperform individual models.
- K-Means Clustering (intermediate): If implemented, explain the k-means objective function and how you selected k; discuss whether clustering reveals meaningful passenger subgroups and how results differ from supervised classification. If not implemented, explain when unsupervised clustering is appropriate vs. supervised prediction.
Model Evaluation
- Cross Validation (intermediate): Explain why k-fold cross-validation is preferable to a single train-test split for estimating model generalization on this dataset; discuss how the number of folds affects variance and computational cost.
- Confusion Matrix (intermediate): Given the confusion matrix output from your model, interpret what each quadrant represents for the Titanic survival prediction task and describe how false negatives and false positives differ in practical impact.
- Precision Recall F1 (intermediate): Describe the trade-off between precision and recall for predicting survival; explain which metric matters more if the goal is to identify high-risk passengers and justify your choice with reference to your computed values.
How to submit
- Before you start, register on SahkaarX and connect your GitHub account.
- When the challenge begins, SahkaarX creates a private repository under your account and notifies you in the app and via a push notification; clone that repository to your local machine.
- Implement your pipeline, commit your code and tests regularly, and push all changes to the repository.
- Submit your work in the app using the system-created repository link; do not create your own GitHub repository.
What happens after you submit
When the challenge window closes, an automated system reviews your repository for code quality, test coverage, and correctness. You will then be invited to a mandatory in-app conversation where you explain your data cleaning decisions, feature engineering rationale, model choice, and how you validated your results. This conversation verifies your understanding of your own work and is required for all participants. If human judges are assigned, they review your repo score and conversation transcript before final results are published; otherwise results finalize automatically after the conversation.
Intellectual property
You retain full ownership of the code and analysis in your submission. SahkaarX may host, evaluate, display on leaderboards, and operate the challenge using your work. 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.
Skills You’ll Put to Work
Version Control
- Repository SetupBeginnerFundamental
- Basic CommandsBeginnerFundamental
- CommitsBeginnerFundamental
- BranchingBeginnerFundamental
- MergingBeginnerFundamental
- Conflict ResolutionIntermediateFundamental
- Pull RequestsIntermediateFundamental
SQL
- SELECT QueriesBeginnerFundamental
- JOINsIntermediateFundamental
- GROUP BYIntermediateFundamental
- Basic SQL QueriesIntermediateFundamental
- SQL Join SIntermediateFundamental
- Aggregation & GroupingIntermediateFundamental
- Basic Subqueries & Cte SBeginnerFundamental
Python Programming
- Virtual EnvironmentsBeginnerFundamental
- Functions & ModulesIntermediateFundamental
- Object-Oriented ProgrammingIntermediateFundamental
- Type HintsIntermediateFundamental
- Python Syntax & Data StructuresIntermediateFundamental
- Basic OOP ConceptsBeginnerFundamental
- Error Handling & DebuggingIntermediateFundamental
Pandas
- GroupByIntermediateFundamental
- Merge & JoinIntermediateFundamental
Data Cleaning & Preprocessing
- Missing ValuesIntermediateFundamental
- Outlier DetectionIntermediateFundamental
- Scaling & NormalizationIntermediateFundamental
Exploratory Data Analysis
- Scaling & NormalizationIntermediateFundamental
- Data ProfilingIntermediateFundamental
- Correlation AnalysisIntermediateFundamental
- Business InsightsIntermediateFundamental
Statistical Fundamentals
- Descriptive StatisticsIntermediateFundamental
- ProbabilityIntermediateFundamental
- Hypothesis TestingIntermediateFundamental
Data Visualization
- MatplotlibIntermediateFundamental
- SeabornIntermediateFundamental
Feature Engineering
- Feature SelectionIntermediateFundamental
- Feature EncodingIntermediateFundamental
Machine Learning
- Linear RegressionIntermediateFundamental
- Logistic RegressionIntermediateFundamental
- Decision TreesIntermediateFundamental
- Random ForestIntermediateFundamental
- K-Means ClusteringIntermediateFundamental
Model Evaluation
- Cross ValidationIntermediateFundamental
- Confusion MatrixIntermediateFundamental
- Precision Recall F1IntermediateFundamental
Before You Register
- Prerequisites: review the target audience, skills covered, and challenge brief.
- Deadlines: check the key dates and complete required submissions before the challenge deadline.
- Participation: Solo only.
- Evaluation: review the brief and FAQs for scoring criteria and how your work will be assessed.
- AI assistance: check this challenge's rules before using AI tools. If the rules are unclear, ask support before submitting.
Questions? Contact SahkaarX support.
Intellectual property: participants retain
Frequently Asked Questions
Who can join this challenge?
Entry-level data scientists and anyone with foundational Python, pandas, and basic ML knowledge. Solo participation only; teams are not allowed.
Do I need to create my own GitHub repository?
No. SahkaarX creates a private repository for you when the challenge starts. Clone that repo, implement your solution, and push your changes there.
When does evaluation happen?
Automated repo review runs after the challenge window closes, not immediately after you submit. You will then complete a mandatory in-app conversation to explain your work.
What is the mandatory in-app conversation?
After repo review, you discuss your data cleaning, feature engineering, model selection, and validation approach with the evaluator. This verifies you understand your own submission and is required for all participants.
Skill feedback helps you decide what to practise next. Learning plans follow eligible evaluated results; additional plans are paid. No job guarantee.