To document a short data science internship on GitHub, create one repository per project, write a README that lets a stranger reproduce your result in ten minutes, commit in small labelled steps, and audit the whole history for secrets and personal data before sharing the link. In a 14-day internship, this takes about 20 to 30 minutes a day if you do it as you go, and far longer if you leave it to the last evening.
This guide gives CHARUSAT students a README template, a repository structure checklist, a commit-message habit guide, a worked illustrative example and a pre-submission audit. It is an independent guide and is not issued or endorsed by the university.
Why a documented repository matters more than a big one
A reviewer, faculty member or recruiter usually opens a repository for under two minutes. They look at the README, the folder layout, and a few commits. A small project that is explained clearly beats a sprawling notebook dump, because it shows that you understand the problem, can structure work, and can communicate results.
Data science repositories fail in predictable ways: a notebook that only runs on the author’s laptop, a dataset with no source, no statement of the metric, and a commit history that reads “update”, “final”, “final2”. Each of these is avoidable with the habits below.
A 14-day plan for building the repository as you work
Documentation done daily is cheap. This schedule assumes a 14-day internship with one main project. Adjust the days to your track.
| Days | Project focus | Repository task |
|---|---|---|
| 1 | Understand the problem and data | Create the repo, add a licence, .gitignore and a README skeleton with the problem statement |
| 2-3 | Data collection and cleaning | Record the data source and licence; commit the cleaning script, not just a notebook |
| 4-5 | Exploratory analysis | Save 3 to 5 key figures to a reports/figures folder; note findings in the README |
| 6-8 | Baseline and feature work | Commit a simple baseline first; log metrics in a small results table |
| 9-10 | Model improvement | Pin library versions in requirements.txt; record random seeds |
| 11 | Error analysis | Write a short limitations section |
| 12 | Clean-up | Restructure folders, remove dead code, restart-and-run-all the notebook |
| 13 | Pre-submission audit | Run the leak audit below; test a fresh clone |
| 14 | Final polish | Tag a release, finalise README, share the link |
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.
Repository structure checklist for a short data science project
Use a layout that is familiar to anyone who has seen a data project. Tick each item before submitting.
project-name/
├── README.md
├── LICENSE
├── .gitignore
├── requirements.txt
├── .env.example
├── data/
│ ├── README.md (source, licence, how to download)
│ ├── raw/ (usually not committed)
│ └── processed/ (small samples only)
├── notebooks/
│ └── 01_eda.ipynb
├── src/
│ ├── clean_data.py
│ ├── train.py
│ └── evaluate.py
├── reports/
│ └── figures/
└── results/
└── metrics.csv
- One-line description on the GitHub repository page itself, plus topics such as
data-scienceandmachine-learning. - Notebooks numbered in the order they should be run, with outputs cleared or intentionally kept.
- Reusable logic in
src/, not copied across notebooks. - A data folder README that says where each file came from and whether you may redistribute it.
- Pinned dependencies with versions, so the project installs a year from now.
- A
.env.examplelisting variable names with fake values, never the real file. - No large binaries: model files and datasets over roughly 50 MB belong in a release, a download script or external storage.
- A licence, chosen deliberately. If the dataset restricts reuse, say so.
README template for a two-week data science internship project
Copy this into README.md and replace the bracketed text. Keep it honest: if something did not work, write that down.
# [Project title: say what it predicts or explains]
[One sentence: the problem, the data, and the headline result.]
## Context
- Internship: 14-day online data science internship, [month year]
- Track: [your track]
- My role: [individual project / what you personally did]
## Problem statement
[Who would use this result and what decision it supports.]
## Data
- Source: [name and link]
- Licence / terms: [state it, or "check source before reuse"]
- Size: [rows x columns]; period covered: [dates]
- Target variable: [name and definition]
- Personal data: [none / anonymised how]
## Approach
1. Cleaning: [missing values, duplicates, outliers handled how]
2. Features: [what you created and why]
3. Models: [baseline, then improved model]
4. Validation: [split method, metric, why that metric]
## Results
| Model | Metric | Score |
|-------|--------|-------|
| Baseline | [e.g., F1] | [value] |
| Final | [e.g., F1] | [value] |
Key findings: [3 bullet points in plain language]
## Limitations
[Data bias, small sample, leakage risks, what you would test next.]
## How to reproduce
```bash
git clone [repo-url]
cd [project]
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt
python src/clean_data.py
python src/train.py
```
Python version: [x.y]. Random seed: [n].
## Repository layout
[Short tree or bullet list]
## Author
[Name, programme, LinkedIn or email you are happy to make public]
What makes each README section earn its place
- Context tells the reader the scale of work. Without it, a two-week project can look like an unfinished six-month one.
- Data is where most student repositories are weakest. Source, licence and the personal-data line protect you.
- Validation shows you know a score means nothing without a sensible split.
- Limitations is a sign of maturity, not weakness.
Commit-message habits that make a short project readable
Your history is documentation too. Aim for 25 to 50 meaningful commits across 14 days rather than three giant ones.
- Commit one idea at a time. Cleaning and modelling changes should not share a commit.
- Use a short imperative subject under about 60 characters: “Add median imputation for age column”.
- Prefix with a type if it helps:
data:,eda:,model:,docs:,fix:,chore:. - Put the why in the body when it is not obvious: why you dropped a column, why you chose the metric.
- Record metric changes: “model: tune max_depth, F1 0.71 to 0.74 on validation”.
- Commit at the end of each work session, even if the work is partial, but never commit a broken notebook as “final”.
- Do not commit outputs you cannot explain.
| Weak message | Stronger replacement (illustrative) |
|---|---|
| update | eda: add correlation heatmap for numeric features |
| final | docs: add reproduction steps and limitations to README |
| fixed bug | fix: stop scaling before train-test split to avoid leakage |
| new model | model: add random forest baseline, F1 0.68 on validation |
| changes | data: drop 112 duplicate rows after checking IDs |
Worked illustration: documenting a customer churn project
This example is illustrative. The project, numbers and file names are invented to show the method; no code was run.
Suppose a student builds a churn predictor on a public telecom dataset. On Day 1 she creates churn-prediction-internship, adds a Python .gitignore, and writes the problem statement: “Predict which customers are likely to cancel so a retention team can prioritise calls.”
On Day 3 she commits src/clean_data.py with the message data: convert TotalCharges to numeric and impute blanks with median. In data/README.md she writes the dataset link and notes that she did not verify redistribution rights, so the raw file is excluded and a download step is documented instead.
On Day 7 she commits a logistic regression baseline and records it in results/metrics.csv. On Day 10 she realises her scaler was fitted on the full dataset before splitting, fixes it, and commits fix: fit scaler on training split only. The score drops slightly, and she notes this in the README under Limitations, which makes the repository more trustworthy.
On Day 13 she runs the audit below, finds a hard-coded API key in an early notebook cell for a weather-data experiment she abandoned, revokes the key, removes it from history, and only then makes the repository public.
Pre-submission audit for leaked credentials and private data
Deleting a secret in a later commit does not remove it. Anyone can read old commits. Run this audit on Day 13, not Day 14.
Credentials and keys
- Search the whole project for strings such as
api_key,token,secret,password,AKIA,Bearer,mongodb+srvandpostgres://. - Check every notebook, including saved outputs, which can print keys or file paths.
- Confirm
.env,*.pem,*.jsoncredential files and cloud config folders are listed in.gitignore. - Search the full history, not just the current files, for the same terms. Tools such as
git log -pwith a search, or a dedicated secret scanner, can help. - If anything was ever committed, revoke or rotate it first. Rewriting history is secondary, because the key may already be copied.
Private or personal data
- Check datasets for names, phone numbers, email addresses, Aadhaar-style IDs, addresses or exact locations.
- Confirm you have the right to publish any data given to you by an organisation. If unsure, do not upload it.
- Remove personal details from notebook metadata, such as local usernames in file paths like
C:\Users\yourname\. - Check screenshots and figures for visible emails, tabs or dashboards.
- Look at the commit author email. GitHub offers a no-reply address if you do not want your personal one public.
Final reproducibility test
- Clone the repository into a new folder, create a fresh environment, and follow only your README.
- Run the notebook with “restart and run all”.
- Open the repository in a private browser window to see what an outsider sees.
CHARUSAT students: what to settle before you publish internship work
CHARUSAT is a state private university, and its official About page says curricula are set through its own Academic Council, Faculty Boards and Boards of Studies. That matters here because the format of what you submit for an internship, whether a report, a presentation or a repository link, is a university and institute decision, not something this guide can dictate.
The university’s centralized Career Development and Placement Cell says it supports students in finding summer and final-year internships. It is a sensible first contact if you need to know how an external internship is recorded. A university NAAC document, published without a stated year, refers to short-term industry exposures of 2 to 4 weeks in a four-year programme (an excerpt, so read the current version). A 14-day project fits that general range, but whether yours counts for anything formally is not something to assume.
Programme syllabus booklets are published on the university download pages, for example a 2023-24 B.Tech AIML booklet, and rules may differ by institute and programme. Whether online internships are accepted, and what documents are required, should be confirmed in writing rather than inferred from this article.
If you are doing the free two-week online internship from CareerSwami, you receive an offer letter and a completion certificate after successful completion. Whether your department accepts these is for your department to say.
Verification steps before you make your repository public
- Email your department coordinator or internship in-charge asking: “Is a GitHub repository link acceptable as part of internship documentation, and in what format?”
- Ask CDPC (the cell lists a head and phone number on its page) whether an online external internship needs prior approval or a specific letter.
- Look in your own programme’s current syllabus booklet for internship or project-work rules, and note the scheme year.
- Ask whether your institute treats a public repository as acceptable, or prefers a private repository shared with the evaluator.
- If your project uses data from a company or faculty member, get permission in writing before publishing it.
- Keep the email replies; attach them if a question arises later.
Polishing the repository after the audit
- Pin a result image or table near the top of the README so the finding is visible without scrolling.
- Tag a release such as
v1.0-internshipso the submitted state is frozen even if you keep improving the project. - Add a short “What I learned” paragraph, specific to the project, not generic praise for the experience.
- Link only what you are comfortable making public: a professional email, LinkedIn, not a phone number.
- Do not overclaim. Say “baseline and one improved model” if that is what you built.
Frequently Asked Questions
Should a data science internship repository be public or private?
Public is better for a portfolio, but only if the audit passes and you own or may share the data. If the data belongs to an organisation, use a private repository and add the evaluator as a collaborator.
Can I upload the dataset to GitHub?
Only if its licence allows redistribution and the file is small. Otherwise link to the source and provide a download script. GitHub rejects files over 100 MB in a normal push, and large files make cloning slow anyway.
I accidentally committed an API key. Is deleting the file enough?
No. The key remains in history and may already be scraped. Revoke or regenerate it with the provider immediately, then remove it from history with a history-rewriting tool if you still want the repository public.
How many commits should a 14-day project have as a Charotar University of Science & Technology student?
There is no fixed number. A range of 25 to 50 focused commits is typical for steady daily work. Quality matters more: each commit should describe one understandable change.
Should I commit Jupyter notebooks with outputs?
Keep outputs when they are the evidence, such as plots and metrics, but check them for paths, emails and keys. Clear them for notebooks that are only scratch work.
What should I do if my model result is poor?
Document it honestly. Show the baseline, what you tried, and what you suspect limits performance. A clearly explained modest result is more credible than an unexplained high score that may involve leakage.
Do I need a licence file for an internship project?
Without one, others have no legal permission to reuse your code. MIT is a common permissive choice for personal work, but check whether an organisation or the internship terms claim any rights over your output.
How can the CareerSwami internship fit into this documentation workflow?
Use the 14 days as your schedule: set up the repository on Day 1, commit daily, and run the audit on Day 13. State the internship dates and your track in the README’s Context section.
Related Data Science guides
- Rishihood University Students: Pitching Yourself to a Startup for a Data Science Internship
- MSCB University Students: Exploratory Data Analysis Steps for Your First Internship Task
- Shri Vaishnav Vidyapeeth Students: Common Reasons Data Science Interns Fail and How to Avoid Them
- 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.




















