AI Data Challenge - Week of 05 Oct 2026

Problem definition

Analyze customer data to predict churn using Python, scikit-learn, and OpenCV. Input data (download): https://raw.githubusercontent.com/IBM/telco-customer-churn-on-icp4d/master/data/Telco-Customer-Churn.csv (columns such as tenure, MonthlyCharges, Contract, Churn). Out of scope: UI polish.

Every line under Success criteria is in scope for this challenge. Evaluation considers all of those topics, so your code should demonstrate as many skills and topics as possible.

Task brief

Develop a predictive model for customer churn.

Version Control

Master Version Control to manage changes in the customer churn prediction project.

Programming Fundamentals

Master Programming Fundamentals to analyze customer data and predict churn using Python.

Debugging & Troubleshooting

Debugging & Troubleshooting is essential for an AI engineer to ensure the reliability and accuracy of predictive models in customer churn analysis.

Ai Assisted Software Development

Leverage AI-assisted software development to analyze customer data and predict churn using Python, scikit-learn, and OpenCV.

Containerization (Docker)

Master containerization with Docker to ensure your churn prediction model is consistently deployable and scalable.

Package & Dependency Management

Master Package & Dependency Management to ensure the AI model for predicting customer churn is built and deployed with consistent and secure dependencies.

Language and stack

Required language is Python with pytest, scikit-learn, and OpenCV.

Scenario

You are an AI engineer for a telecom company. You need to analyze customer data to predict churn and improve retention strategies.

Deliverables

1. A Python script for data preprocessing and model training.
2. A Jupyter notebook for model evaluation and visualization.

Success criteria

AI evaluation scores every topic bullet below. Aim to demonstrate as many of these skills and topics as possible in your repository.

Version Control

• Repository Setup (beginner): A local copy of the repo is cloned and set up.
• Basic Commands (beginner): The learner can list, view, and modify files in the repo.
• Commits (beginner): The learner can create and view commits.
• Branching (beginner): The learner can create and switch between branches.
• Merging (beginner): The learner can merge branches into the main branch.
• Conflict Resolution (intermediate): The learner can resolve merge conflicts and complete the merge.
• Pull Requests (intermediate): The learner can create and review pull requests.

Programming Fundamentals

• Variables & Data Types (beginner): Correctly declare and initialize variables with appropriate data types.
• Operators (beginner): Use arithmetic, comparison, and logical operators correctly in expressions.
• Expressions (beginner): Construct and evaluate expressions involving variables and operators.
• Control Flow (beginner): Implement if-else statements and loops to control the flow of the program.
• Functions & Methods (beginner): Define and call functions to encapsulate reusable code.
• Collections (intermediate): Use lists, dictionaries, and sets to store and manipulate collections of data.
• Exception Handling (intermediate): Implement try-except blocks to handle exceptions gracefully.
• File Handling (beginner): Read and write data to files using appropriate file handling techniques.

Debugging & Troubleshooting

• Breakpoints (beginner): The learner sets breakpoints in the Python code to inspect variables and control flow.
• Debugging Techniques (beginner): The learner uses debugging tools to step through code and identify logical errors.
• Logging (beginner): The learner implements logging to capture runtime information and errors.
• Stack Traces (intermediate): The learner interprets stack traces to diagnose and fix exceptions.
• Root Cause Analysis (intermediate): The learner performs root cause analysis to identify and resolve underlying issues.

Ai Assisted Software Development

• Working with AI Assistants (beginner): Utilize AI to assist in writing and debugging Python code for churn prediction.
• Prompt Writing Fundamentals (beginner): Create clear and concise prompts for the AI to generate code snippets.
• Code Generation (beginner): Generate Python code for data preprocessing and model training.
• AI-assisted Debugging (beginner): Use AI to identify and fix bugs in the churn prediction model.
• AI-assisted Refactoring (intermediate): Refactor existing code for better performance and readability with AI assistance.
• AI-assisted Unit Testing (intermediate): Develop unit tests for the churn prediction model using AI-generated test cases.
• AI-assisted Documentation (beginner): Generate documentation for the churn prediction model using AI.
• AI Output Validation (intermediate): Validate the accuracy and reliability of AI-generated code and documentation.
• AI Limitations & Hallucinations (beginner): Identify and mitigate potential limitations and hallucinations in AI-generated outputs.
• Responsible AI Usage (beginner): Ensure ethical and responsible use of AI in the development process.

Containerization (Docker)

• What is Containerization (beginner): Define containerization and its benefits in software deployment.
• Docker Architecture (beginner): Describe the basic components of Docker architecture.
• Docker Images (beginner): Create a Docker image for the churn prediction model.
• Docker Containers (beginner): Run a Docker container from the created image.
• Dockerfile Basics (beginner): Write a Dockerfile to build the churn prediction model image.
• Building Images (beginner): Successfully build a Docker image using the Dockerfile.
• Running Containers (beginner): Start a Docker container from the built image and verify it runs correctly.
• Environment Variables (beginner): Use environment variables to configure the Docker container at runtime.
• Docker Volumes (beginner): Mount a Docker volume to persist data between container restarts.
• Docker Networks (beginner): Create a Docker network to allow containers to communicate.
• Docker Compose (intermediate): Use Docker Compose to define and run multi-container Docker applications.
• Container Debugging (intermediate): Diagnose and resolve common issues in Docker containers.

Package & Dependency Management

• Package Managers Overview (beginner): Identify and use a package manager to manage dependencies.
• Semantic Versioning (beginner): Understand and apply semantic versioning for dependencies.
• Version Constraints (intermediate): Specify version constraints in dependency files.
• Installing Dependencies (beginner): Install required dependencies for the project.
• Dependency Lock Files (intermediate): Use dependency lock files to ensure consistent environments.
• Updating Dependencies (intermediate): Update dependencies to the latest compatible versions.
• Transitive Dependencies (intermediate): Understand and manage transitive dependencies.
• Private Package Repositories (beginner): Access and use packages from private repositories.
• Publishing Packages (beginner): Publish a package to a repository.
• Dependency Security & Vulnerability Scanning (intermediate): Scan dependencies for security vulnerabilities.
• License Management (beginner): Check and manage licenses of dependencies.
• Dependency Best Practices (intermediate): Apply best practices in managing dependencies.

How to submit

1. Register and connect your GitHub account.
2. Clone the system-created private repo and implement your solution.
3. Push your changes and submit in the app.

What happens after you submit

AI repo review runs when the challenge window closes. A mandatory in-app conversation follows to verify understanding. If human judges exist, they review repo scores and the conversation transcript before final results.

Intellectual property

Participants own the intellectual property in their submission. SahkaarX may host, evaluate, display on leaderboards, and otherwise operate the challenge. The GitHub repository is a private repo under the participant or team leader account.