A group data science project works in 14 days only if the team agrees on roles, file names, branch rules and review deadlines on Day 1, before anyone writes analysis code. The charter, naming scheme and Git guide below are built for that: small teams, one shared notebook outcome, and no lost work at merge time.
Why group data science projects fail in two weeks
Data science teams rarely fail because of weak modelling. They fail because three people clean the same column in three different ways, two notebooks overwrite each other, and nobody reviews anything until the last evening. A 14-day internship leaves no room to recover from that.
The usual failure points are predictable:
- Silent duplication: two members both build the cleaning step because nobody owned it.
- Notebook conflicts: Jupyter notebooks store outputs and metadata, so two edited copies are painful to merge.
- Unreproducible results: a chart appears in the report but nobody can say which cell or data version produced it.
- Review at the end: errors found on Day 13 cannot be fixed on Day 13.
If you are starting the free two-week online internship at CareerSwami with classmates, treat the charter below as the first thing you produce together. It takes about 45 minutes and saves days.
The team charter template for a data science group
Copy this into a shared document or a CHARTER.md file at the top of your repository. Fill every line; a blank line is a future argument.
TEAM CHARTER
Project title:
Dataset and source:
Question we are answering (one sentence):
Final deliverable (report / notebook / slides):
Team members and roles:
Project lead:
Data wrangler:
Analyst / modeller:
Reviewer and documentation owner:
Communication channel and reply window (e.g. 12 hours):
Daily check-in time (10 minutes):
Review turnaround: every pull request reviewed within 24 hours
Branch rule: nobody commits directly to main
File naming rule: see naming table
Random seed used everywhere: 42
Definition of done: notebook runs top to bottom, reviewer approved
If someone goes silent for 24 hours: lead reassigns their task
Signed off by all members on (date):
Role definitions that avoid overlap
| Role | Owns | Does not own |
|---|---|---|
| Project lead | Task board, daily check-in, final merge to main, deadline tracking | Writing all the code |
| Data wrangler | Loading, cleaning, missing values, a documented cleaned dataset | Model choice |
| Analyst / modeller | Exploration, features, models, evaluation metrics | Changing the cleaning rules without telling the wrangler |
| Reviewer and documentation owner | Reading every pull request, README, final report assembly, checking reproducibility | Approving their own work |
With a team of three, merge the reviewer role into the lead and have analyst and wrangler review each other. With a team of five, add a visualisation owner who controls chart style and figure files.
Free 2-Week CareerSwami Internship
Online, 14 days, with a free offer letter and a free completion certificate once you finish the work. Check with your college that it fits your requirement before you enrol.
Naming conventions for notebooks, data files and figures
A naming rule is useful only if you can read the file name and know who made it, what stage it is, and which version. Use lowercase, underscores, and no spaces.
| Item | Pattern | Illustrative example |
|---|---|---|
| Notebook | stage_topic_owner.ipynb | 02_cleaning_priya.ipynb |
| Raw data | raw_source_date.csv (never edited) | raw_retail_2026-11-14.csv |
| Cleaned data | clean_vN.csv | clean_v2.csv |
| Figure | fig_number_description.png | fig03_sales_by_month.png |
| Branch | role/task | wrangler/fix-missing-values |
| Commit message | Verb + what changed | Add median imputation for age |
Numbered prefixes (01, 02, 03) keep notebooks in pipeline order: 01 exploration, 02 cleaning, 03 features, 04 modelling, 05 evaluation. Folders should be simple: data/raw, data/clean, notebooks, figures, report.
How to merge notebooks without destroying each other’s work
The safest approach is to avoid merging notebooks at all. Give each stage its own notebook and a single owner, so two people never edit the same .ipynb file.
- Split by stage, not by cell. One notebook per pipeline stage, each reading the previous stage’s output file.
- Move shared code into a .py file. Functions used by everyone (for example a
load_data()helper) live inutils.py, which merges cleanly as plain text. - Clear outputs before committing. Use Kernel > Restart and Clear Output, or agree to commit with outputs only on the final version. Outputs create huge, unreadable differences.
- Pass data through files. The wrangler saves
clean_v2.csv; the analyst loads it. Nobody copies cells between notebooks. - Assemble the final notebook last. The documentation owner creates
final_report.ipynbby copying cells from approved notebooks in one sitting, then runs Restart and Run All. - Test the full run. If the final notebook fails at any cell, fix it before submitting.
A beginner Git branching guide for a four-person data team
You need only five ideas: repository, branch, commit, pull request, merge. The model below is deliberately small.
The branch rules
mainalways holds work that runs and has been reviewed.- Each task gets its own short-lived branch named
role/task. - Branches live no longer than two days; long branches cause painful conflicts.
- Every merge into
maingoes through a pull request with at least one reviewer who is not the author.
The daily command sequence
# 1. Start of day: get the latest main
git checkout main
git pull
# 2. Create your branch
git checkout -b analyst/baseline-model
# 3. Work, then check what changed
git status
# 4. Save a snapshot
git add notebooks/04_modelling_arjun.ipynb
git commit -m "Add logistic regression baseline"
# 5. Upload your branch
git push -u origin analyst/baseline-model
# 6. Open a pull request on GitHub, ask for review
# 7. After approval and merge, tidy up
git checkout main
git pull
git branch -d analyst/baseline-model
When a conflict appears
- Do not panic and do not delete the file.
- Run
git pull origin mainon your branch; Git marks the clashing lines with<<<<<<<and>>>>>>>. - Open the file, keep the correct lines, remove the markers.
- Run
git addandgit commit, then push again. - If the file is a notebook, ask its owner to decide which version wins.
Add a .gitignore that excludes .ipynb_checkpoints/, __pycache__/ and large raw data files. Share big datasets through a link noted in the README instead.
Review turnaround rules that keep a 14-day project moving
A review rule needs a deadline and a checklist, otherwise reviewers skim. Agree on these limits in the charter.
| Item | Rule |
|---|---|
| Review window | 24 hours from the pull request, shortened to 12 hours in Days 11 to 14 |
| Pull request size | One task per request; ask for a split if the reviewer needs more than 20 minutes |
| Feedback format | Specific comment plus suggested fix, not “looks wrong” |
| Escalation | If no review in the window, the lead reviews or assigns another member |
| Author response | Fix comments within 12 hours |
Reviewer checklist for data science pull requests
- Does the notebook run from top to bottom after a restart?
- Is the random seed set where randomness is used?
- Is the train/test split made before any scaling or imputation that learns from data (to avoid leakage)?
- Are metrics appropriate to the problem, such as precision and recall for imbalanced classes rather than accuracy alone?
- Do charts have titles, axis labels and units?
- Are assumptions and cleaning decisions written in markdown cells?
A 14-day team schedule with checkpoints
| Days | Team goal | Checkpoint |
|---|---|---|
| 1 | Sign charter, set up repository, choose dataset | Everyone can clone, branch and push |
| 2-3 | Exploration and data quality notes | Written list of data problems |
| 4-5 | Cleaning pipeline | clean_v1.csv approved |
| 6-8 | Features and baseline model | Baseline metric recorded |
| 9-10 | Improved models, comparison | Comparison table in notebook |
| 11 | Freeze analysis; no new experiments | Main branch tagged |
| 12-13 | Final notebook, figures, report, rehearsal | Restart and Run All passes |
| 14 | Final review and submission | All members confirm |
Illustrative example: a team of four on a retail churn dataset
This is an invented scenario to show the rules in action, not a record of a real team or a run of real code. Four students pick a public customer churn dataset. Meera is lead, Karan is wrangler, Sana is modeller, and Dev is reviewer.
On Day 1 they sign the charter and agree that missing values in tenure will be handled only by Karan. On Day 4 Karan opens a pull request from wrangler/fix-missing-values containing 02_cleaning_karan.ipynb and clean_v1.csv. Dev reviews within 24 hours and notices that Karan scaled the full dataset before the split. He comments with a fix; Karan corrects it and the request is merged.
Sana, meanwhile, had started on a branch from Day 3. Because she pulled main after the merge, she works from clean_v1.csv and not her own cleaning copy. On Day 11 Meera freezes experiments. Dev assembles final_report.ipynb, runs Restart and Run All, and one cell fails because a path was hard-coded to Sana’s laptop. They fix it with a relative path on Day 12, which is why the Day 12 to 13 buffer exists.
Indus International University: what students should know before planning group project work
The university describes itself as a private not-for-profit university in Una, Himachal Pradesh, established in 2009. Its School of Science & Technology lists B.Tech CSE, BCA, M.Tech CSE and MCA, so students in these programmes are the likeliest to run a data science group project, although the page gives no syllabus and does not say how data science content is taught.
The Training & Placement Cell lists industrial internships and domain skill development among its activities, and describes a flow from training to internship to campus drive. That tells you internships are part of the university’s stated approach, but not how a self-chosen online internship is treated.
The Academic Regulations page covers exams, the 75% attendance requirement for the final test, grading and holidays. It contains no internship or project-work rules, and no semester dates. Do not assume that group work completed in an online internship earns marks, credit or exemption. Equally, plan your 14 days around your timetable and test dates, which you must check directly.
Verification steps for your team:
- Email your programme coordinator asking in writing whether an external online internship can be recorded in your academic file, and in what form.
- Ask the Training & Placement Cell whether group projects from an internship can be shown in placement preparation or resume reviews.
- Check your semester timetable and Mid Semester Test dates with your department before fixing the Day 1 start date.
- Ask your faculty whether the university has any policy on sharing datasets or using student data in external projects.
- Request the current academic regulations or ordinances document, and ask if it has internship clauses beyond the public page.
Handling common teamwork breakdowns in a data science group
One member does most of the work
Use the commit history and pull request list as an objective record. At the Day 6 check-in, compare tasks completed against the charter and redistribute the next block of tasks.
Two members disagree on a modelling choice
Run both as branches against the same split and metric, then choose on the result. Record the decision in the notebook so the report explains why.
A member disappears
The 24-hour rule in the charter lets the lead reassign. Keep tasks small enough that any member can pick up another’s branch from the commit messages.
The data changes midway
Never edit the raw file. Save a new clean_vN.csv, note the change in the README, and rerun downstream notebooks.
Final submission checklist for the team
- Repository has README with project question, data source, folder map and run instructions.
- Final notebook passes Restart and Run All.
- Requirements listed, such as
pandasandscikit-learn, with versions noted. - Every figure in the report traces to a notebook cell.
- Each member can explain every step, not only their own.
- Contribution list agrees with the commit history.
Keep any offer letter and completion certificate you receive from the internship with your project folder, since the certificate is awarded after successful completion.
Frequently Asked Questions
How many people should be in a group data science internship project?
Three or four works best for 14 days. With two, there is no independent reviewer; with six or more, coordination costs eat the time you have for analysis.
Should we use GitHub or just share notebooks on Google Drive?
Use Git with a hosted repository. Drive overwrites files silently and cannot show who changed which line, while Git gives history, review and recovery.
Can two people edit the same Jupyter notebook?
Avoid it. Notebooks save outputs and metadata, which produce messy conflicts. Give each notebook one owner and pass data between stages through files.
What should be in the first commit of the repository?
A README, the signed charter, a .gitignore, the folder structure, and the raw data link or file if it is small enough. Keep raw data unedited from the start.
How do we split work if some members are weaker at coding?
Match tasks to strengths and pair for one session. A weaker coder can own documentation, chart design or data-quality checks, then take a small modelling task after review feedback.
Will Indus International University count our group internship project for credit?
That is not stated on the public pages checked for this article, which include no internship or project-work rules. Ask your programme coordinator in writing and keep the reply.
How often should the team merge into main?
Merge each approved task as soon as it passes review, usually every one or two days. Small, frequent merges produce fewer conflicts than one large merge near the deadline.
Can our team practise this workflow in the CareerSwami internship?
Yes, the free two-week online internship is a good setting to practise the charter and branching routine on a real project timeline. Agree on the charter before starting the first task.
Related Data Science guides
- K.R. Mangalam University Students: Writing a Data Science Internship Viva Question Bank
- J.S. University Students: Learning Pandas in Two Weeks Before a Data Internship
- YBN University Students: Finding Free Datasets for a Credible Internship Project
- All Data Science internship guides
Ready to put this into practice?
Join the free two-week CareerSwami online internship in Data Science. The internship, the offer letter and the completion certificate are free.




















