IT Internship Glossary | IT Terms Every Student Should Know

Browse IT Internship Terms

This glossary is designed for learning and career preparation. Companies may use different tools, processes and terminology depending on their technology stack and work culture.

Acceptance Criteria

Agile & Teams

Simple definition: The specific conditions a user story must meet before it is considered done.
Example: "The reset link expires after 30 minutes" and "an unregistered email shows an error" are acceptance criteria.
Why it matters: They tell you exactly when your work is complete. Read them before you start, not after.

Accountability

Professional Workplace

Simple definition: Accepting responsibility for your actions and their results, including your mistakes.
Example: "I missed that edge case in my change. I've fixed it and added a test so it doesn't happen again."
Why it matters: Owning a mistake openly builds trust far faster than hiding it.

Accuracy

Data & AI

Simple definition: How often a model's predictions are correct, usually given as a percentage.
Example: The model correctly classifies 90 of 100 test emails, so its accuracy is 90%.
Why it matters: Accuracy alone can mislead, especially for rare events — a point interviewers like to check.

Action Item

Project & Workplace Tools

Simple definition: A specific task someone agrees to do after a meeting, usually with an owner and a due date.
Example: The meeting ends with an action item for you: "Share the test results by Friday."
Why it matters: Completing your action items without being reminded is one of the simplest ways to build trust.

Agile

Agile & Teams

Simple definition: A way of working where teams build software in small pieces, get feedback often and adjust their plans regularly, instead of planning everything upfront.
Example: Your team delivers a small working part of a feature every two weeks and changes the next steps based on feedback.
Why it matters: Most IT teams describe themselves as Agile. Knowing the idea helps you understand their meetings and planning.

Analytics

Data & AI

Simple definition: Using data to measure and understand what is happening — usage, performance and trends — usually through reports and dashboards.
Example: Product analytics show that most users leave the sign-up page at the phone-number step.
Why it matters: Teams use analytics to decide what to build or fix next, so your features may be measured this way.

API

Software Development · Data & AI

Simple definition: A defined way for one piece of software to talk to another. An API lets an app ask a service for data or actions without knowing how that service works inside.
Example: Your app calls a weather API to get today's temperature, or an AI model's API to summarise some text.
Why it matters: APIs are everywhere in modern software and AI tools. Interns often build, test or call APIs in their first projects.

Aptitude Test

Interview

Simple definition: A test of logical reasoning, numerical ability and verbal skills, often used as the first round of campus drives.
Example: A 60-minute online test with questions on percentages, logical puzzles and grammar.
Why it matters: Many capable candidates are filtered out at this early step. A little regular practice goes a long way.

Artificial Intelligence (AI)

Data & AI

Simple definition: The broad field of building systems that do tasks which normally need human intelligence, such as understanding language, recognising images or making decisions.
Example: A support chatbot that understands customer questions and suggests answers is an AI feature.
Why it matters: AI comes up everywhere now. Understanding the basics helps you tell real capability apart from hype.

Authentication

Software Development

Simple definition: Checking who someone is — usually with a password, an OTP or "Sign in with Google".
Example: Logging in to the company portal with your email and password is authentication.
Why it matters: Login features are common intern tasks, and confusing authentication with authorization is a common interview mistake.

Authorization

Software Development

Simple definition: Checking what someone is allowed to do after they have logged in.
Example: You can log in to the project tool, but only admins are authorized to delete projects.
Why it matters: Many security bugs come from missing authorization checks. Knowing the difference shows you think about safety.

Automation Testing

Testing & QA

Simple definition: Using code and tools to run tests automatically instead of by hand.
Example: A Playwright or Selenium script logs in, adds an item to the cart and checks the total every night.
Why it matters: Automation skills are in demand for QA roles, but they build on good manual testing thinking.

Availability

Cloud & DevOps

Simple definition: How much of the time a system is up and usable, often written as a percentage such as 99.9%.
Example: A promise of 99.9% availability allows less than nine hours of downtime in a year.
Why it matters: It explains why teams are careful with production changes and treat outages so seriously.

AWS

Cloud & DevOps

Simple definition: Amazon Web Services: Amazon's cloud platform and one of the most widely used.
Example: The project stores uploaded images in AWS S3 and runs its servers on AWS EC2.
Why it matters: AWS appears in many JDs. You don't need all its services — learn the few your role actually uses.

Azure DevOps

Project & Workplace Tools

Simple definition: A Microsoft platform that combines work tracking, code repositories, build pipelines and releases in one place.
Example: Your team's code, Pull Requests and sprint board all live in Azure DevOps.
Why it matters: It is common in companies that use Microsoft technologies, and may be where you both code and track tasks.

Backend

Software Development

Simple definition: The server-side part of an application that handles logic, data, security and communication with databases and other services.
Example: Checking the password on the server and creating a login session is backend work.
Why it matters: Knowing whether a bug is in the frontend or backend saves time when you start debugging.

Backlog

Agile & Teams

Simple definition: A list of work the team may do in the future — features, bugs and improvements — usually ordered by priority.
Example: Your idea for improving the search page is added to the backlog for a future sprint.
Why it matters: Not everything gets done right away. The backlog explains why some work waits.

Behavioral Interview

Interview

Simple definition: An interview about how you have handled real situations — teamwork, disagreements, mistakes and deadlines.
Example: "Tell me about a time you disagreed with a teammate. What did you do?"
Why it matters: Answers based on a real situation, what you did and what happened are far more convincing than general claims.

Blocker

Project & Workplace Tools

Simple definition: Anything that stops you from continuing your work.
Example: "I'm blocked because I don't have access to the test database."
Why it matters: Raise blockers quickly. Staying stuck and silent for days is one of the most common intern mistakes.

Branch

Git & Version Control

Simple definition: A separate line of work in a repository, so you can make changes without affecting the main code until they are ready.
Example: You create a branch called feature/password-reset for your task.
Why it matters: Teams almost never work directly on the main code. Working on branches is standard practice.

Bug

Agile & Teams · Testing & QA

Simple definition: A problem where the software doesn't behave the way it is supposed to.
Example: Clicking "Save" on the profile page does nothing on mobile — that is a bug.
Why it matters: You will both fix and report bugs. A clear bug report with steps to reproduce saves everyone time.

Campus Placement

Internship & Career

Simple definition: Hiring through your college placement cell, where companies visit or run online drives for that college's students.
Example: A company holds a test for all eligible students on campus and shortlists 30 of them for interviews.
Why it matters: It is a common route to internships and first jobs, with its own rules, timelines and offer policies.

Career Goal

Interview

Simple definition: What you want to achieve in your career, in the short and long term.
Example: "In the next two years, I want to become a strong backend developer and learn system design."
Why it matters: A realistic goal related to the role shows direction. A vague answer suggests you haven't thought about it.

CI/CD

Cloud & DevOps

Simple definition: The combined automated process of building, testing and deploying code, usually set up as a "pipeline".
Example: After every merge, the team's CI/CD pipeline builds the app, runs the tests and deploys it to the test environment.
Why it matters: CI/CD appears in many JDs. Understanding the idea is enough to start; the tools differ between companies.

Clone

Git & Version Control

Simple definition: Downloading a full copy of a remote repository, including its history, to your own computer.
Example: On day one, you run git clone with the repository link to get the project onto your laptop.
Why it matters: It is usually the first Git command you run on a new project.

Cloud Computing

Cloud & DevOps

Simple definition: Using computing resources such as servers, storage and databases over the internet from a provider, instead of buying and running your own machines.
Example: Your company runs its application on cloud servers it pays for by usage, not on machines in its office.
Why it matters: Most modern applications run in the cloud, so you will hear about it in almost every team.

Cloud Storage

Cloud & DevOps

Simple definition: Storing files and data on a cloud provider's servers and accessing them over the internet.
Example: User profile pictures are uploaded to cloud storage instead of being saved on the application server.
Why it matters: Many features you build will save or read files from cloud storage.

Code Quality

Software Development

Simple definition: How easy code is to read, understand, test and change — not just whether it works.
Example: Two solutions both work, but the one with clear names and small functions is easier for the next person to change.
Why it matters: Teams maintain code for years. Readable code is valued more than clever code.

Code Review

Software Development

Simple definition: When teammates read your code changes before they are merged, to catch problems and suggest improvements.
Example: A senior developer comments on your Pull Request asking you to rename a variable and handle empty input.
Why it matters: Code review is one of the fastest ways to learn. Treat comments as guidance, not as criticism of you.

Coding Assessment

Interview

Simple definition: An online test where you solve programming problems within a time limit, usually marked automatically.
Example: You get 90 minutes to solve three coding problems on an online platform.
Why it matters: It is a common screening round. Practise solving problems against the clock, not just reading solutions.

Coding Interview

Interview

Simple definition: An interview where you solve programming problems, often live, while explaining your approach.
Example: You are asked to write a function that checks whether a string is a palindrome and explain how efficient it is.
Why it matters: Practice helps — but explaining your thinking clearly matters as much as the final code.

Collaboration

Professional Workplace

Simple definition: Working with others towards a shared goal — sharing information, helping and coordinating.
Example: You sit with a tester to reproduce a bug together instead of arguing over chat about whether it exists.
Why it matters: Software is built by teams. People who collaborate well are often valued more than lone experts.

Commit

Git & Version Control

Simple definition: A saved snapshot of your changes in Git, with a short message describing what you changed.
Example: You commit your work with the message "Add email validation to sign-up form".
Why it matters: Small commits with clear messages make your work easy to review — and easy to undo if something breaks.

Communication

Professional Workplace

Simple definition: Sharing information clearly — updates, questions and problems — in meetings, chat and email.
Example: Instead of "It's not working", you write "The login API returns 500 when the email contains a + sign. Steps are below."
Why it matters: Clear communication saves your team time and makes you much easier to help.

Communication Skills

Interview

Simple definition: How clearly you explain ideas, listen, ask questions and write — especially about technical topics.
Example: You explain your project in two minutes in a way a non-technical HR person can follow.
Why it matters: Interviewers notice communication in every round, not only the HR round.

Compiler

Software Development

Simple definition: A tool that converts the code you write into something the computer can run, and reports mistakes before the program runs.
Example: The Java compiler stops with an error because you missed a semicolon on line 42.
Why it matters: Reading compiler errors calmly and carefully is one of the most useful beginner skills.

Confluence

Project & Workplace Tools

Simple definition: A documentation tool where teams write pages about projects, processes, decisions and how-to guides.
Example: The setup guide for your project is on a Confluence page your mentor shares on day one.
Why it matters: Many answers to your questions are already written down. Search the team's documentation before asking.

Constructive Feedback

Professional Workplace

Simple definition: Feedback that points out what can be better and how, in a specific and helpful way.
Example: "Your test covers the normal case. Add cases for empty input and invalid dates."
Why it matters: It is meant to help, not to criticise you. Thank the person, ask if something is unclear, and apply it.

Container

Cloud & DevOps

Simple definition: A lightweight package containing an application and everything it depends on, which runs the same way on any machine.
Example: The API runs in one container and the database in another.
Why it matters: Containers are common in modern deployments. The basic idea is enough to follow most team discussions.

Continuous Deployment (CD)

Cloud & DevOps

Simple definition: Automatically releasing tested changes to an environment, sometimes all the way to production. "Continuous delivery" is similar but keeps a manual approval before production.
Example: Once your change is merged and the tests pass, it is deployed to the testing environment automatically.
Why it matters: It explains why merged code can appear in an environment within minutes.

Continuous Integration (CI)

Cloud & DevOps

Simple definition: Automatically building and testing the code every time someone pushes changes, so problems are caught early.
Example: When you push your branch, the CI check runs all the tests and shows a red cross because one test failed.
Why it matters: A failing CI check usually means your Pull Request can't be merged yet. Learn to read what failed and why.

CRUD

Software Development

Simple definition: Short for Create, Read, Update and Delete — the four basic operations on data.
Example: An admin page that lets you add, view, edit and remove products is a CRUD feature.
Why it matters: Many first projects and interview tasks are CRUD applications.

Daily Stand-up

Agile & Teams

Simple definition: A short daily team meeting, often 15 minutes, where each person shares what they did, what they will do next and whether anything is blocking them.
Example: "Yesterday I finished the form validation. Today I'll write the tests. I'm blocked on access to the test database."
Why it matters: It is your daily chance to be visible and ask for help. Keep your update short and specific.

Data

Data & AI

Simple definition: Facts and records that are collected and stored — such as orders, clicks, marks or messages — which software uses, shows or analyses.
Example: Every time someone places an order, the system records data like the date, amount and items bought.
Why it matters: Almost every IT role works with data in some way, from storing it to analysing it.

Data Analysis

Data & AI

Simple definition: Examining data to find patterns, answer questions and support decisions, often with Excel, SQL, Python or dashboards.
Example: You analyse last month's sales data to find which product sold best in each city.
Why it matters: It is a role of its own and a useful skill in many other roles.

Data Science

Data & AI

Simple definition: Using statistics, programming and machine learning to find insights in data and build models that make predictions.
Example: A data science team builds a model that predicts which customers are likely to cancel their subscription.
Why it matters: It is a popular career path. Knowing the real work — lots of data cleaning and testing — helps you decide if it suits you.

Database

Software Development · Data & AI

Simple definition: An organised place where an application stores and finds data, such as users, orders or products. MySQL, PostgreSQL, SQL Server and MongoDB are common examples.
Example: When someone signs up, the application saves their details as a new row in the users table.
Why it matters: Almost every application uses one. Basic database knowledge helps you build correct features and debug data problems.

Dataset

Data & AI

Simple definition: A collection of related data used for analysis or for training and testing models, often stored as a table or file.
Example: You download a public dataset of house prices to practise building a prediction model.
Why it matters: Working with real datasets, including their messy parts, is a big share of data and AI work.

Deadline

Project & Workplace Tools · Professional Workplace

Simple definition: The date or time by which a piece of work must be finished.
Example: The feature must be ready for testing by Wednesday because the release is on Friday.
Why it matters: If you might miss a deadline, say so early. Teams can plan around a delay they know about.

Debugging

Software Development

Simple definition: Finding out why code isn't working and fixing it — by reading errors, adding logs, using breakpoints and checking your assumptions one by one.
Example: A breakpoint shows you that a variable is already empty before it reaches the save function.
Why it matters: Interns spend a lot of time debugging. Doing it step by step is valued far more than guessing.

Defect

Testing & QA

Simple definition: A flaw where the software doesn't meet its requirements. Many teams use "defect" and "bug" to mean the same thing; some use "defect" for formally logged issues.
Example: The requirement says passwords need at least 8 characters, but the system accepts 5, so you log a defect.
Why it matters: Knowing both words helps you follow your team's bug-tracking language.

Deliverable

Project & Workplace Tools

Simple definition: A specific output you are expected to produce, such as a feature, report, document or presentation.
Example: Your internship deliverables are a working dashboard and a final presentation.
Why it matters: Knowing your deliverables tells you exactly what you will be evaluated on.

Dependency

Project & Workplace Tools

Simple definition: Something your work relies on that you don't fully control — another team's API, access, a decision or someone else's task.
Example: You can't finish the payment screen until the backend team completes the payment API.
Why it matters: Mention dependencies early. It prevents last-minute surprises for you and the team.

Deployment

Software Development · Cloud & DevOps

Simple definition: Moving a new version of software onto the servers or environment where it runs, so people can use it.
Example: After testing, the team deploys the new release to production on Thursday evening.
Why it matters: Deployments are usually planned and checked carefully, which is why "just push it live" is rarely an option.

Development Environment

Software Development

Simple definition: The setup where developers build and try out code — usually their own machine plus shared development servers.
Example: You run the application locally with test data before pushing your changes.
Why it matters: Getting your development environment working is often your very first real task.

DevOps

Cloud & DevOps

Simple definition: A way of working that brings development and operations together, using automation to build, release and run software reliably. It is also a job role.
Example: A DevOps engineer sets up the pipeline that deploys your code and the alerts that fire when something breaks.
Why it matters: It tells you who looks after deployments and infrastructure — and it is a career path some interns choose.

Docker

Cloud & DevOps

Simple definition: A popular tool for packaging an application with everything it needs into a container, so it runs the same way everywhere.
Example: Instead of installing a database on your laptop, you start one with a single Docker command.
Why it matters: Many teams use Docker to make setup consistent, so "it works on my machine" problems happen less often.

Documentation

Project & Workplace Tools

Simple definition: Written information about a project — how it works, how to set it up, what was decided and how to use it.
Example: After solving a tricky setup issue, you add the fix to the project documentation for the next intern.
Why it matters: Reading documentation saves time, and improving it is a useful way to contribute even as a beginner.

Eligibility Criteria

Internship & Career

Simple definition: The minimum conditions you must meet to apply, such as degree, graduation year, branch or marks.
Example: A campus drive is open only to 2027 graduates from CS, IT and ECE with no active backlogs.
Why it matters: Check eligibility before applying. It saves time and avoids rejections that have nothing to do with your skills.

Email Etiquette

Professional Workplace

Simple definition: Writing professional emails: a clear subject, a polite greeting, short and specific content, and the right people in To and CC.
Example: Subject: "Request for test database access – Asha (Intern, Payments team)", followed by a two-line explanation and a thank-you.
Why it matters: Unclear emails get ignored or misunderstood. Clear ones get faster replies.

Entry-Level

Internship & Career

Simple definition: A role meant for people starting their career, with basic required skills and some training provided.
Example: An "Entry-Level QA Engineer" role may ask for testing basics and SQL, but not years of experience.
Why it matters: Most students start here. Reading entry-level requirements shows you which skills to build first.

Environment

Cloud & DevOps

Simple definition: A separate setup where an application runs for a specific purpose — such as development, testing, staging or production — each with its own servers, data and settings.
Example: A bug appears in the testing environment but not in development because the two use different settings.
Why it matters: Many problems only happen in one environment. Always say which environment you saw an issue in.

Epic

Agile & Teams

Simple definition: A large piece of work that is broken down into smaller user stories.
Example: "Online payments" is an epic containing stories like "pay by UPI", "pay by card" and "view payment history".
Why it matters: It shows how your small task fits into a bigger goal.

Error Handling

Software Development

Simple definition: Writing code that deals with expected problems gracefully — showing a useful message, retrying or logging the issue — instead of crashing.
Example: If the payment service is down, your code shows "Please try again later" and logs the error instead of showing a blank page.
Why it matters: Reviewers check error handling. It is often the difference between code that works and code that is ready for real users.

Escalation

Project & Workplace Tools · Professional Workplace

Simple definition: Raising an issue to someone with more authority or context when it can't be solved at your level, or when it is urgent.
Example: A blocker has stopped your work for three days, so after following up normally, you escalate it to your manager.
Why it matters: Escalating isn't complaining. Done politely and with facts, it is the responsible thing to do.

Exception

Software Development

Simple definition: An error that happens while a program runs and interrupts its normal flow, such as reading a missing file or using a null value.
Example: Your code throws a NullPointerException because a customer record wasn't found.
Why it matters: The exception message and stack trace tell you where things went wrong. Read them before searching online.

Expected Stipend

Interview

Simple definition: The stipend you hope to receive, which interviewers may ask you about.
Example: "I'm flexible, but based on similar roles I was expecting around ₹15,000–20,000 per month."
Why it matters: Research typical stipends for the role and city beforehand so you can answer calmly and reasonably.

Feature Branch

Git & Version Control

Simple definition: A branch created for one specific feature, fix or task.
Example: You work on feature/add-search-filter and delete the branch after it is merged.
Why it matters: It keeps each piece of work separate and easy to review. Teams often have naming rules for branches.

Feedback

Professional Workplace

Simple definition: Comments about your work or behaviour that are meant to help you improve.
Example: Your mentor says your code works, but your commit messages are hard to understand.
Why it matters: Interns who ask for feedback and act on it improve the fastest.

Fork

Git & Version Control

Simple definition: Your own copy of someone else's repository on GitHub or a similar service, which you can change without affecting the original.
Example: To contribute to an open-source project, you fork it, make changes in your copy and then open a Pull Request to the original.
Why it matters: Forks are common in open source. Inside companies, teams usually use branches instead.

Framework

Software Development

Simple definition: A ready-made structure for building applications that decides how your code is organised and provides common features. Spring Boot, ASP.NET, Django and Angular are examples.
Example: The team uses Spring Boot, so your new API has to follow its project structure and conventions.
Why it matters: Most company projects are built on a framework. Learning one well matters more than trying many.

Fresher

Internship & Career

Simple definition: Someone with little or no full-time work experience, usually a recent graduate. In India, it is the common word for entry-level candidates.
Example: A job post says "Freshers can apply" — they don't expect previous full-time experience.
Why it matters: Many openings are aimed specifically at freshers, so this word helps you find roles you are eligible for.

Frontend

Software Development

Simple definition: The part of an application users see and interact with — screens, buttons and forms — usually built with HTML, CSS, JavaScript and a framework.
Example: Building the login screen and its validation messages is frontend work.
Why it matters: It tells you which part of the system a task belongs to, and who to ask about it.

Full Stack

Software Development

Simple definition: Working on both the frontend and the backend of an application.
Example: A full stack intern might build a form on the screen and also the API that saves its data.
Why it matters: Many JDs mention full stack. It usually means comfortable on both sides — not an expert in everything.

Full-Time Opportunity

Internship & Career

Simple definition: The possibility of a permanent job after or during your internship, depending on your performance and the company's needs.
Example: An internship listing says "Full-time opportunity based on performance" — a job offer is possible, not promised.
Why it matters: Read this phrase carefully. It usually describes a chance you can earn, not a guarantee.

Functional Requirement

Software Development

Simple definition: What the system should do — a specific feature or behaviour.
Example: "The system should send an order confirmation email after payment" is a functional requirement.
Why it matters: It tells you exactly what to build and what testers will check.

Functional Testing

Testing & QA

Simple definition: Testing that each feature does what the requirements say it should.
Example: You check that applying a valid coupon reduces the order total by the correct amount.
Why it matters: Most of the manual testing interns do is functional testing.

Generative AI

Data & AI

Simple definition: AI that creates new content — text, code, images or audio — based on patterns it learned from large amounts of data.
Example: A tool that drafts an email or suggests code from a short description uses generative AI.
Why it matters: Many companies use these tools at work. Always check your company's rules before pasting code or data into one.

Git

Git & Version Control

Simple definition: The tool most software teams use to keep track of every change made to the code. It lets you see history, undo mistakes and work on the same project as others without overwriting each other's work.
Example: Before starting a task, you create a new branch in Git so your changes don't affect anyone else.
Why it matters: Almost every IT internship expects basic Git. You will use it from your first week.

GitHub

Git & Version Control

Simple definition: A website that stores Git repositories online and adds team features like Pull Requests, code review and issue tracking. GitLab, Bitbucket and Azure Repos are similar services.
Example: Your team's code lives on GitHub, and you open a Pull Request there when your change is ready.
Why it matters: It is also your public portfolio — recruiters often look at students' GitHub profiles.

GitHub Profile

Interview

Simple definition: Your public page on GitHub showing your repositories, activity and README files.
Example: A recruiter opens your profile and sees three well-documented projects with clear READMEs.
Why it matters: A tidy profile supports your resume. An empty or messy one doesn't add much.

.gitignore

Git & Version Control

Simple definition: A file that tells Git which files or folders not to track, such as build output, local settings or secret keys.
Example: You add node_modules/ and .env to .gitignore so they are never committed.
Why it matters: It stops you from accidentally committing huge folders or passwords — a common beginner mistake.

Google Cloud

Cloud & DevOps

Simple definition: Google's cloud platform (often called GCP), with services for computing, storage, data analytics and AI.
Example: A data team uses Google Cloud's BigQuery to analyse very large datasets.
Why it matters: The major clouds share similar ideas. Once you understand one, the others become much easier.

HR Interview

Interview

Simple definition: An interview, usually with someone from HR, about your background, attitude, communication, expectations and fit with the company.
Example: HR asks why you want to join, whether you can relocate and when you can start.
Why it matters: Strong technical candidates still get rejected here for careless or unclear answers. Prepare for it too.

HTTP

Software Development

Simple definition: The protocol browsers and servers use to send requests and responses. It defines methods (like GET and POST) and status codes (like 200 OK, 404 Not Found and 500 Server Error).
Example: Your API returns a 401 status code, which tells you the request wasn't authenticated.
Why it matters: Methods and status codes are the first clues when debugging anything on the web.

Hybrid Work

Professional Workplace

Simple definition: A mix of working some days in the office and some days remotely.
Example: Your team works from the office on Tuesdays and Thursdays and from home on other days.
Why it matters: Use office days for discussions, pairing and getting to know people.

IDE

Software Development

Simple definition: Integrated Development Environment: the application you write code in, with features like autocomplete, debugging and Git built in. VS Code, IntelliJ IDEA and Visual Studio are common ones.
Example: Your team uses IntelliJ IDEA, so you install it and open the project on your first day.
Why it matters: Learning your IDE's debugger and shortcuts makes you noticeably faster.

Initiative

Professional Workplace

Simple definition: Doing useful things without being asked — spotting problems, suggesting improvements or learning ahead.
Example: You notice the setup guide is out of date, so you update it and let your mentor know.
Why it matters: Small, sensible initiative stands out. Check with your mentor before making big changes on your own.

Integration Testing

Software Development

Simple definition: Testing that different parts of a system work correctly together, such as your API with the real database.
Example: An integration test checks that saving an order through the API actually stores it in the database.
Why it matters: Code can pass its unit tests and still fail once it is connected to other parts.

Intern

Internship & Career

Simple definition: A student or fresh graduate who joins a company for a limited time to learn on the job. Interns usually get smaller, well-defined tasks and a mentor to guide them.
Example: As an intern, you might be asked to write tests for an existing module before you touch any new features.
Why it matters: Nobody expects an intern to know everything. They do expect you to learn, ask questions and follow through on what you take on.

Internship

Internship & Career

Simple definition: A fixed period where you work in a real company team as a learner, doing actual tasks under guidance. In IT, it is usually your first look at how software is built and delivered outside college.
Example: During a 6-month internship, you fix small bugs in the company's web application and attend the team's daily meetings.
Why it matters: Companies treat internships as a trial run for both sides — you learn the work, and they see how you learn, communicate and deliver.

Internship Agreement

Internship & Career

Simple definition: A document you and the company (sometimes your college too) sign, listing the terms of the internship — duties, duration, stipend, confidentiality and rules.
Example: Before joining, you sign an agreement that says you cannot share the company's code or data outside the company.
Why it matters: It sets out your rights and responsibilities. If something is unclear, ask before you sign, not after.

Internship Duration

Internship & Career

Simple definition: How long the internship lasts — for example 2, 3, 6 or 12 months. It is mentioned in the offer and is sometimes extended.
Example: Your college needs a 6-month internship in the final semester, so you only apply to openings of that duration.
Why it matters: Duration affects how much real work you get to do and whether it fits your academic calendar. Check it before you accept.

Internship Offer

Internship & Career

Simple definition: The formal message or letter saying you have been selected, with details such as role, duration, stipend, location and joining date.
Example: After your final interview, HR emails an internship offer letter that you need to accept within three days.
Why it matters: Read every line before accepting. It is the reference for what was promised to you if anything is unclear later.

Internship Program

Internship & Career

Simple definition: A planned internship scheme run by a company, often with a fixed start date, a batch of interns, training and an evaluation at the end.
Example: A company's summer internship program includes two weeks of training, a team project and a final presentation.
Why it matters: Programs usually have a set structure and review, so knowing how it works tells you early what you will be measured on.

Jira

Project & Workplace Tools

Simple definition: A widely used tool for tracking work items such as stories, tasks and bugs, usually on sprint or Kanban boards.
Example: Your mentor assigns you a Jira ticket, and you move it from "To Do" to "In Progress" when you start.
Why it matters: If your company uses it, you will probably open it every day. Keeping your tickets updated is part of the job.

Job Description (JD)

Internship & Career

Simple definition: The listing that explains a role: responsibilities, required skills, eligibility, location and other details.
Example: The JD for a backend intern asks for Java, SQL and basic Git, so you revise those before the interview.
Why it matters: JDs are the best guide to what companies actually want. Read several for your target role and note what repeats.

Joining Date

Internship & Career

Simple definition: The date you officially start the internship or job.
Example: Your offer says your joining date is 1 July, so you plan travel and college formalities around it.
Why it matters: Changing it at the last minute leaves a poor first impression. If you need a different date, ask early and politely.

JSON

Software Development

Simple definition: A simple text format for structured data, written as keys and values. Most APIs send and receive JSON.
Example: { "name": "Asha", "role": "Intern" } is a small piece of JSON.
Why it matters: You will read and write JSON constantly when working with APIs and configuration files.

Kanban

Agile & Teams

Simple definition: A way of managing work on a board with columns such as To Do, In Progress and Done, focusing on a steady flow of work rather than fixed sprints.
Example: The support team uses a Kanban board and picks up the next ticket as soon as one is finished.
Why it matters: Even Scrum teams use Kanban-style boards. Moving your cards correctly keeps everyone informed.

Knowledge Transfer (KT)

Project & Workplace Tools

Simple definition: Sessions where someone explains a project, system or process to the people who will work on it next.
Example: Before a senior developer moves to another project, they give you a KT session on the reporting module.
Why it matters: KT is common when you join a team. Take notes and ask questions — you may not get a second session.

Kubernetes

Cloud & DevOps

Simple definition: A system for running and managing many containers across many servers — starting them, restarting failed ones and adding more when needed. Often written K8s.
Example: When traffic increases, Kubernetes automatically starts more copies of your application's container.
Why it matters: You don't need to master it as an intern, but you will hear it often in larger companies.

Large Language Model (LLM)

Data & AI

Simple definition: A type of generative AI model trained on huge amounts of text that can understand and write human-like language.
Example: The team calls an LLM through an API to summarise long customer support tickets.
Why it matters: LLMs power many current AI products, and building features with them is a fast-growing area of work.

Library

Software Development

Simple definition: Reusable code you call when you need it for a specific job. Unlike a framework, your own code stays in control.
Example: You use a date library to format dates instead of writing that logic yourself.
Why it matters: Trusted libraries save time, but teams often have rules about which ones you may add.

Logging

Software Development

Simple definition: Recording useful messages about what an application is doing — events, warnings and errors — so people can investigate problems later.
Example: You log a message when an order fails, including the order ID, so support can trace what happened.
Why it matters: In real systems, logs are often the only way to understand a problem. Never log passwords or personal data.

Machine Learning (ML)

Data & AI

Simple definition: A way of building software that learns patterns from examples in data, instead of only following rules a person wrote.
Example: A spam filter learns from thousands of example emails which messages are likely to be spam.
Why it matters: Machine learning is part of many products, so you may work on features that use it even outside data roles.

Main Branch

Git & Version Control

Simple definition: The primary branch of a repository, holding the stable, accepted code. Usually named main (older projects use master).
Example: Your team protects the main branch, so changes can only reach it through an approved Pull Request.
Why it matters: Never push untested work directly to main — most teams don't allow it anyway.

Manual Testing

Testing & QA

Simple definition: Testing software by hand — using it like a real user and checking the results — without automation scripts.
Example: You manually test a new page on different browsers and screen sizes.
Why it matters: Good manual testing is the foundation of QA. It teaches you how software breaks.

Meeting

Project & Workplace Tools

Simple definition: A scheduled discussion, in person or online, to share updates, make decisions or solve a problem.
Example: You have a weekly one-to-one meeting with your mentor to discuss your progress.
Why it matters: Joining on time, coming prepared and following up on decisions are basic professional habits.

Meeting Etiquette

Professional Workplace

Simple definition: Good habits in meetings — joining on time, coming prepared, muting when not speaking, not interrupting and following up.
Example: In an online meeting, you keep your update short, note your action items and switch on your camera if that's the team norm.
Why it matters: Meetings are where many people see you. Small habits make a lasting impression.

Merge

Git & Version Control

Simple definition: Combining the changes from one branch into another.
Example: Once your Pull Request is approved, your feature branch is merged into the main branch.
Why it matters: Merging is the moment your work becomes part of the real product.

Merge Conflict

Git & Version Control

Simple definition: When Git can't combine two changes automatically because both edited the same lines, so a person has to decide what the final code should be.
Example: You and a teammate both changed the same function, so Git shows a conflict when you merge.
Why it matters: Conflicts are normal, not a disaster. Resolve them carefully, and ask the other person if you aren't sure which change is right.

Microsoft Azure

Cloud & DevOps

Simple definition: Microsoft's cloud platform, offering services such as virtual machines, databases, storage and AI tools.
Example: Your team hosts its .NET application and SQL database on Azure.
Why it matters: If your company uses Azure, a basic feel for its portal and main services will help you follow discussions.

Microsoft Teams

Project & Workplace Tools

Simple definition: A workplace chat, calling and meeting tool used by many companies.
Example: Your daily stand-up is a Teams call, and project discussions happen in a team channel.
Why it matters: How you write messages and join calls on it becomes part of how people see you.

Milestone

Project & Workplace Tools

Simple definition: An important checkpoint in a project, such as finishing a phase or a major release.
Example: The first milestone is completing the login and registration modules by the end of the month.
Why it matters: Milestones show you the bigger timeline and where your work fits into it.

Mock Interview

Interview

Simple definition: A practice interview with a friend, senior or mentor that feels like the real thing.
Example: A senior interviews you for 30 minutes and points out that you speak too fast when explaining your project.
Why it matters: It is one of the most effective ways to improve before real interviews.

Model

Data & AI

Simple definition: In machine learning, the result of training on data — something that takes new input and produces a prediction or other output.
Example: The trained model takes the details of a loan application and predicts the risk of default.
Why it matters: When data teams say "the model", they mean this trained component, not a diagram or design.

Monitoring

Cloud & DevOps

Simple definition: Continuously tracking an application's health — errors, speed and usage — and alerting the team when something goes wrong.
Example: A monitoring alert tells the team that the checkout page has suddenly started returning errors.
Why it matters: It is how teams find problems in real systems, often before users report them.

Non-Functional Requirement

Software Development

Simple definition: How well the system should work — speed, security, reliability, usability and similar qualities.
Example: "The search page should load within 2 seconds" is a non-functional requirement.
Why it matters: Code that works but is slow or insecure can still fail. Beginners often forget these requirements.

NoSQL

Data & AI

Simple definition: Databases that don't use traditional tables with fixed columns. They store data as documents, key-value pairs or graphs instead. MongoDB is a common example.
Example: A chat app stores messages as flexible documents in a NoSQL database.
Why it matters: It explains why some projects don't use SQL tables, and when each type of database fits better.

Notice Period

Internship & Career · Interview

Simple definition: The time you must keep working after you resign, or that a company gives before ending your role. In interviews, it also means how soon you can join.
Example: HR asks, "What is your notice period?" As a student, you can say you can join after your final exams on a specific date.
Why it matters: It comes up in almost every HR conversation. For students, a clear joining date is usually the right answer.

Off-Campus Placement

Internship & Career

Simple definition: Applying for internships or jobs on your own, outside the college placement process — through career pages, job portals, referrals or LinkedIn.
Example: You find an internship on a company's careers page and apply directly.
Why it matters: Many good opportunities never come to campus. Applying off-campus widens your options.

Onboarding

Internship & Career

Simple definition: Your first days or weeks when the company sets you up: accounts, laptop, access, policies, team introductions and training.
Example: During onboarding, you get your company email, access to the code repository and a session explaining the project.
Why it matters: This is the easiest time to ask basic questions. Use it to learn how the team and its tools work.

Ownership

Professional Workplace

Simple definition: Taking responsibility for your work from start to finish — testing it, following up and fixing problems — without being chased.
Example: After your fix is deployed, you check it actually works in the testing environment instead of assuming it does.
Why it matters: Ownership is one of the qualities that most often turns interns into full-time hires.

Paid Internship

Internship & Career

Simple definition: An internship where you receive a monthly stipend for your work.
Example: An offer that says "₹15,000 per month stipend for 6 months" is a paid internship.
Why it matters: Pay isn't the only thing that matters, but always confirm the amount and payment schedule in writing before you join.

Portfolio

Interview

Simple definition: A collection of your work that shows your skills — projects, designs, case studies or analyses — often on a website or GitHub.
Example: A UI/UX student shares three case studies; a developer shares links to live projects.
Why it matters: Real work you can show is often more convincing than a list of skills.

Prediction

Data & AI

Simple definition: The output a model gives for new input — a value, a category or a probability.
Example: For a new email, the model's prediction is "spam" with 92% confidence.
Why it matters: Predictions can be wrong. Treat them as estimates and understand their limits.

Pre-Placement Offer (PPO)

Internship & Career

Simple definition: A full-time job offer given to an intern before regular campus placements, usually because they did well during the internship.
Example: At the end of your summer internship, your manager tells you the team is giving you a PPO for next year.
Why it matters: A PPO can secure your first job early, which is a big reason to treat your internship seriously from day one.

Priority (in bug tracking)

Testing & QA

Simple definition: How soon a bug should be fixed, based on business needs. It can be different from severity.
Example: A typo in the company name on the home page is low severity but high priority, because every visitor sees it.
Why it matters: "What is the difference between severity and priority?" is a favourite interview question.

Priority (in daily work)

Professional Workplace

Simple definition: How important or urgent a task is compared with your other tasks.
Example: Your mentor says the production bug is top priority today, so you pause the documentation task.
Why it matters: When you have several tasks, ask which comes first instead of guessing.

Probation

Internship & Career

Simple definition: A trial period after joining as a regular employee, when the company reviews your performance before confirming you. It is more common in full-time jobs than in internships.
Example: Your full-time offer mentions a 6-month probation period with a review at the end.
Why it matters: During probation, steady work and good conduct matter a lot, and the notice period is often shorter.

Problem Solving

Interview

Simple definition: Your ability to understand a problem, break it into smaller parts, find a solution and check that it works.
Example: In an interview, you clarify the question, explain a simple approach first, then improve it step by step.
Why it matters: Companies care more about how you think through a problem than about memorised answers.

Product Backlog

Agile & Teams

Simple definition: The complete, prioritised list of everything that might be built into the product. The Product Owner decides its order.
Example: After many user requests, the Product Owner moves "dark mode" higher in the product backlog.
Why it matters: It shows what the business thinks matters most next.

Product Owner

Agile & Teams

Simple definition: The person responsible for deciding what the team builds and in what order, representing users and business needs.
Example: You aren't sure whether search should include archived items, so you ask the Product Owner.
Why it matters: For questions about what a feature should do, the Product Owner usually has the answer.

Production

Software Development

Simple definition: The live system that real users use. Often shortened to "prod".
Example: A bug that only appears in production affects real customers, so it is fixed urgently.
Why it matters: Mistakes in production have real impact. Interns usually don't get direct production access, and that is normal.

Production Environment

Software Development

Simple definition: The servers, databases and settings that run the live application for real users.
Example: Only a few senior engineers can change settings in the production environment, and changes need approval.
Why it matters: Teams protect production carefully. Understanding why helps you respect the approvals and checks.

Professionalism

Professional Workplace

Simple definition: Behaving reliably and respectfully at work — being on time, keeping commitments, communicating clearly and treating people well.
Example: You join meetings on time, tell your mentor before taking leave and reply to messages within a reasonable time.
Why it matters: Interns are judged on how they work as much as on what they build.

Project Discussion

Interview

Simple definition: The part of an interview where you explain a project you built — what it does, how you built it, your decisions and the challenges you faced.
Example: "Why did you use MongoDB instead of MySQL for this project?"
Why it matters: Interviewers use it to check whether you really understand your own work. Be ready to explain everything on your resume.

Prompt

Data & AI

Simple definition: The instruction or input you give a generative AI tool to get a response.
Example: "Summarise this bug report in three bullet points for the Product Owner" is a prompt.
Why it matters: Clear, specific prompts give better results — and the output still needs checking before you use it.

Pull

Git & Version Control

Simple definition: Bringing the latest changes from the shared remote repository into your local copy.
Example: Every morning before you start, you pull the latest changes from the main branch.
Why it matters: Pulling often keeps you working on current code and reduces merge conflicts.

Pull Request (PR)

Git & Version Control

Simple definition: A Pull Request is a request to merge your code changes from one branch into another branch, usually after someone reviews the changes.
Example: You complete a new login feature on your feature branch and create a Pull Request so another developer can review your code.
Why it matters: Pull Requests are commonly used in professional software development teams. Understanding them helps interns participate in real development workflows.

Push

Git & Version Control

Simple definition: Sending your local commits to the shared remote repository so others can see them.
Example: You push your branch to GitHub before opening a Pull Request.
Why it matters: Work that isn't pushed exists only on your laptop. Push regularly so it is backed up and visible.

QA (Quality Assurance)

Testing & QA

Simple definition: The work of making sure software meets the expected quality, through testing, reviews and improving how the team works. QA is also the name of the testing team or role.
Example: Your feature moves to QA, where a tester checks it against the acceptance criteria.
Why it matters: "Send it to QA" is a phrase you will hear often. QA is a partner in quality, not just a gate at the end.

README

Git & Version Control

Simple definition: A text file at the top of a repository that explains what the project is, how to set it up and how to use it.
Example: The README lists the commands you need to run the project on your laptop.
Why it matters: Read it first on any new project. A clear README on your own projects also makes a good impression on recruiters.

Regression Testing

Testing & QA

Simple definition: Re-testing existing features after a change to make sure nothing that used to work is now broken.
Example: After a fix to the cart, you re-run the checkout tests to confirm payments still work.
Why it matters: Many bugs come from a change breaking something else. Regression testing catches them before users do.

Remote Work

Professional Workplace

Simple definition: Working from home or anywhere outside the office, using online tools to work with your team.
Example: Your internship is fully remote, so stand-ups and reviews all happen on video calls.
Why it matters: Remote work needs extra effort in communication. Share updates without being asked so people know your progress.

Repository

Git & Version Control

Simple definition: A project folder tracked by Git, containing the code and its complete change history. Usually called a "repo".
Example: Your mentor shares the link to the backend repository and asks you to clone it.
Why it matters: Projects are often split across several repositories, so "which repo?" is a common first question.

Requirement

Software Development

Simple definition: A description of what the software should do or how it should behave, usually agreed with the business or users.
Example: "Users should be able to reset their password using their registered email" is a requirement.
Why it matters: A lot of rework happens because a requirement was misunderstood. Clarify it before you start coding.

Responsibility

Professional Workplace

Simple definition: The duties and tasks you are expected to handle in your role.
Example: As an intern, your responsibilities may include fixing assigned bugs, writing tests and updating documentation.
Why it matters: Knowing exactly what is expected of you is the first step to doing it well.

REST API

Software Development

Simple definition: A common style of API that uses web addresses (URLs) and HTTP methods such as GET, POST, PUT and DELETE to read or change data.
Example: GET /api/products returns a list of products; POST /api/products adds a new one.
Why it matters: REST APIs are the kind you will meet most often in web projects and interviews.

Resume

Interview

Simple definition: A short document — usually one page for students — summarising your education, skills, projects and experience.
Example: Your resume lists your final-year project with its tech stack and what you built, plus your GitHub link.
Why it matters: It is often the only thing a recruiter sees before deciding to interview you. Keep it specific and honest.

Retrospective

Agile & Teams

Simple definition: A meeting at the end of a sprint where the team discusses what went well, what didn't and what to change next time. Usually called a "retro".
Example: In the retro, the team agrees to write clearer acceptance criteria because several stories were misunderstood.
Why it matters: Teams use it to improve how they work. Honest, respectful input is welcome — even from interns.

Runtime

Software Development

Simple definition: The environment your program runs in, or the time when it is running. A "runtime error" happens while the program is running, not while it is being compiled.
Example: Your code compiles fine but crashes at runtime because a value is null.
Why it matters: It helps you tell errors caught early apart from errors that only appear when the app is used.

Scalability

Cloud & DevOps

Simple definition: A system's ability to handle more users or data by adding resources, without slowing down or breaking.
Example: During a big sale, the shopping site grows from 5 to 50 servers to handle the extra traffic.
Why it matters: It is a common interview topic, and it explains many design decisions in real projects.

Scrum

Agile & Teams

Simple definition: A popular Agile framework with fixed-length sprints, specific roles (Product Owner, Scrum Master and the team) and a regular set of meetings.
Example: Your team follows Scrum, with two-week sprints, a daily stand-up and a retrospective at the end of each sprint.
Why it matters: Many teams use Scrum words even when they adapt the process, and it comes up often in interviews.

Scrum Master

Agile & Teams

Simple definition: The person who helps the team follow Scrum, runs the team meetings and helps remove obstacles.
Example: You tell the Scrum Master you have waited two days for database access, and they follow up with the right team.
Why it matters: When process or access problems block you, the Scrum Master is often the right person to tell.

SDK

Software Development

Simple definition: Software Development Kit: a set of tools, libraries and documentation for building software for a particular platform or service.
Example: You install the Android SDK to build an Android app, or a cloud provider's SDK to upload files from your code.
Why it matters: Installing the right SDKs is often part of your first-week setup.

Selection Process

Internship & Career

Simple definition: The steps a company uses to choose candidates, such as an online test, coding round, technical interview and HR interview.
Example: The selection process is: aptitude test, coding assessment, technical interview, then HR round.
Why it matters: Knowing the rounds in advance tells you exactly what to prepare for and in what order.

Server

Cloud & DevOps

Simple definition: A computer, physical or virtual, that provides a service to other computers — such as running a website, an API or a database.
Example: Your API runs on a server, and the mobile app sends its requests there.
Why it matters: "The server is down" and "restart the server" are things you will hear often in your first weeks.

Severity

Testing & QA

Simple definition: How badly a bug affects the system or its users.
Example: The app crashing during payment is high severity; a spelling mistake in the footer is low severity.
Why it matters: Severity helps the team understand impact. Report it honestly, not dramatically.

Slack

Project & Workplace Tools

Simple definition: A workplace chat tool organised into channels, used by many tech companies for team communication.
Example: You post a question in the #frontend channel instead of messaging five people separately.
Why it matters: Picking the right channel and writing a clear message gets you answers faster.

Smoke Testing

Testing & QA

Simple definition: A quick set of basic checks on a new build to confirm the most important functions work before deeper testing begins.
Example: After a deployment, you check that the app opens, users can log in and the home page loads.
Why it matters: If the smoke tests fail, there is no point in detailed testing yet — the build goes back.

Software Development

Simple definition: The whole work of planning, building, testing and maintaining software. It includes much more than writing code — understanding requirements, reviewing, fixing and improving.
Example: On a development team, a normal day might include reading a requirement, writing code, testing it and fixing review comments.
Why it matters: Coding is one part of the job. Communication, testing and maintenance take just as much of a developer's time.

Software Development Life Cycle (SDLC)

Software Development

Simple definition: The stages software goes through: requirements, design, development, testing, deployment and maintenance. Teams follow these stages in different ways, such as Waterfall or Agile.
Example: Your feature is "in testing" — development is done and QA is checking it before release.
Why it matters: Interviewers often ask about the SDLC, and knowing the stages helps you see where your task fits.

Software Testing

Testing & QA

Simple definition: Checking whether software works as expected by using it and comparing the actual results with the expected results.
Example: You test the sign-up form with valid details, missing fields and an email that is already registered.
Why it matters: Every developer is expected to test their own work — not only testers.

Sprint

Agile & Teams

Simple definition: A short, fixed period — usually one to four weeks — in which the team aims to finish a planned set of work.
Example: In this sprint, your task is to build the profile edit page.
Why it matters: Sprints set the team's rhythm. Knowing the sprint goal helps you decide what to work on first.

Sprint Backlog

Agile & Teams

Simple definition: The items the team has committed to in the current sprint, plus the plan for completing them.
Example: Your two stories for this sprint appear in the sprint backlog on the team's board.
Why it matters: It is effectively your to-do list for the sprint. Keep the status of your items up to date.

Sprint Planning

Agile & Teams

Simple definition: A meeting at the start of a sprint where the team decides which work to take on and roughly how to do it.
Example: In sprint planning, the team picks ten stories from the backlog and your mentor gives you two small ones.
Why it matters: It is where you find out what is expected of you for the next few weeks. Listen carefully and ask questions.

Sprint Review

Agile & Teams

Simple definition: A meeting at the end of a sprint where the team shows the finished work to stakeholders and collects feedback.
Example: You demo the new search filter you built to the Product Owner during the sprint review.
Why it matters: It is a chance to show your work. Prepare a short, clear demo rather than explaining the code line by line.

SQL

Data & AI

Simple definition: Structured Query Language: the standard language for reading and changing data in relational databases.
Example: SELECT name FROM students WHERE city = 'Pune'; lists all students from Pune.
Why it matters: SQL is useful for developers, testers and analysts alike, and it appears in many internship interviews.

Stakeholder

Project & Workplace Tools

Simple definition: Anyone with an interest in a project's outcome — users, clients, managers or other teams.
Example: The finance team is a stakeholder in the reporting feature because they rely on the reports.
Why it matters: Knowing who depends on your work helps you understand why it matters and what "done" really means.

Stipend

Internship & Career

Simple definition: The fixed monthly amount paid to an intern. It is not called a salary because interns are usually not regular employees.
Example: Your offer letter mentions a stipend of ₹20,000 per month, paid at the end of each month.
Why it matters: You need this word to read offers correctly and to answer "expected stipend" questions in interviews.

Story Points

Agile & Teams

Simple definition: A relative number teams use to estimate how much effort or complexity a story involves. They are not hours.
Example: The team estimates a simple form at 2 points and a payment integration at 8 points.
Why it matters: You may be asked to estimate. It is fine to say you are unsure and explain what makes the task uncertain.

Strengths

Interview

Simple definition: The skills or qualities you are good at, which interviewers often ask you to describe.
Example: "One of my strengths is debugging — in my project, I tracked down a data issue the team had been stuck on."
Why it matters: Back each strength with a real example. Adjectives alone don't convince anyone.

Task

Agile & Teams

Simple definition: A small, specific piece of work, often part of a user story.
Example: For the password reset story, your tasks are "create the reset email template" and "add the reset API endpoint".
Why it matters: Tasks are what you will mostly work on and update as an intern.

Teamwork

Professional Workplace

Simple definition: Doing your part in a team, supporting others and putting the team's goal ahead of individual credit.
Example: You finish your task early and offer to help a teammate test before the release.
Why it matters: Mentors notice who helps the team succeed, not only who closes their own tickets.

Technical Debt

Software Development

Simple definition: Extra future work caused by choosing a quick or messy solution now instead of a better one.
Example: To meet a deadline, the same validation code was copied into five places; changing it now means editing all five.
Why it matters: It explains why teams sometimes spend a sprint "cleaning up" instead of adding new features.

Technical Interview

Interview

Simple definition: An interview that checks your technical knowledge and problem-solving — concepts, coding, your projects and how you think.
Example: The interviewer asks the difference between an array and a linked list, then asks about a project you built.
Why it matters: It is a core part of almost every IT internship selection process.

Technical Round

Interview

Simple definition: One stage of a selection process that focuses on technical skills. It could be an interview, a test or a coding exercise.
Example: The company has two technical rounds: one on fundamentals and one on your project.
Why it matters: Knowing how many rounds there are, and what each covers, tells you what to prepare.

Test Case

Testing & QA

Simple definition: A specific, written check: the steps to follow, the input to use and the result you expect.
Example: "Enter a wrong password three times → the account is locked → the user sees a lock message."
Why it matters: Writing clear test cases is a common QA intern task and a common interview exercise.

Test Data

Testing & QA

Simple definition: The input data used for testing, such as sample users, products or orders.
Example: You create test users with different roles to check what each of them can access.
Why it matters: Good test data finds more bugs. Never use real customer data unless the company explicitly allows it.

Test Plan

Testing & QA

Simple definition: A document describing what will be tested, how, by whom, in which environment and on what schedule.
Example: The test plan for a release lists the features in scope, the types of testing and the timeline.
Why it matters: It gives you the big picture of the testing effort you are part of.

Test Scenario

Testing & QA

Simple definition: A higher-level description of something to test, which usually contains several test cases.
Example: "Verify the password reset flow" is a test scenario that covers many test cases.
Why it matters: Scenarios help you plan what to test before you write detailed steps.

Testing Environment

Software Development

Simple definition: A separate setup, similar to production, where testers and the team check changes before release. It may be called QA, test or staging.
Example: Your feature is deployed to the testing environment so the QA team can check it.
Why it matters: It explains why a fix can be "done" but not yet live for users.

Testing (in Data & AI)

Data & AI

Simple definition: Checking how well a trained model performs on data it hasn't seen before, to see whether it will work in the real world.
Example: You keep 20% of the dataset aside and test the model on it after training.
Why it matters: A model that only does well on its training data isn't useful. Testing shows whether it really works.

Time Management

Professional Workplace

Simple definition: Planning and using your time so the important work gets done on time.
Example: You break a three-day task into daily goals and check your progress each evening.
Why it matters: Internships mix learning, meetings and tasks. Managing your time stops you from falling behind without noticing.

Training

Data & AI

Simple definition: Teaching a machine learning model with example data so it learns the patterns in it.
Example: You train a model on two years of sales data so it can predict next month's demand.
Why it matters: Training is only one step. Preparing the data before it and evaluating results after it take just as long.

Trello

Project & Workplace Tools

Simple definition: A simple board-based tool for organising tasks with cards and lists.
Example: A small startup tracks its weekly tasks on a Trello board.
Why it matters: Smaller teams often use simpler tools. The idea is the same: keep the status of your work visible.

Unit Testing

Software Development

Simple definition: Testing small pieces of code, such as a single function, on their own — usually with automated tests.
Example: You write a unit test to check that your discount function gives 10% off orders above ₹1,000.
Why it matters: Many teams expect tests with every change, and writing them is a common first task for interns.

Unpaid Internship

Internship & Career

Simple definition: An internship with no stipend. Some offer a certificate, training or experience instead of pay.
Example: A small startup offers a 2-month unpaid internship with a certificate at the end.
Why it matters: An unpaid internship can still teach you something if the work is real. Be very careful with anyone who asks you to pay them for an "internship".

User Acceptance Testing (UAT)

Testing & QA

Simple definition: Final testing by business users or clients to confirm the software meets their needs before it goes live.
Example: The finance team tries the new invoice screen in UAT and signs off before the release.
Why it matters: UAT can bring last-minute feedback. It is the users' check, not the developers'.

User Story

Agile & Teams

Simple definition: A short description of a feature from the user's point of view, often written as "As a [user], I want [something] so that [reason]".
Example: "As a student, I want to reset my password so that I can log in if I forget it."
Why it matters: Many tasks you receive will be user stories. The "so that" part tells you why the feature matters.

Version Control

Git & Version Control

Simple definition: Any system that tracks changes to files over time, so you can see who changed what, go back to older versions and work together safely. Git is the most widely used one.
Example: When a release breaks something, the team uses version control history to find the exact change that caused it.
Why it matters: It is a basic professional habit. Even your personal projects benefit from it.

Virtual Machine (VM)

Cloud & DevOps

Simple definition: A software-based computer that runs on a physical server, with its own operating system, as if it were a separate machine.
Example: You are given a Linux virtual machine in the cloud to run and test your application.
Why it matters: Virtual machines are a basic cloud building block, and you may be given one to work on.

Weaknesses

Interview

Simple definition: Areas you are still working on. Interviewers ask about them to check your self-awareness.
Example: "I used to hesitate to ask questions, so in my last project I started sharing daily updates and asking early."
Why it matters: Give an honest weakness and what you are doing about it — not a disguised strength like "I work too hard".

Work Ethic

Professional Workplace

Simple definition: Your attitude towards work — reliability, effort, honesty and care for quality.
Example: You test your changes properly even when nobody is checking.
Why it matters: Work ethic is noticed over weeks, not days, and it shapes your references and offers.

Work Experience

Internship & Career

Simple definition: Time spent doing real work in an organisation. Internships usually count as relevant experience on a resume.
Example: On your resume, you list "Software Development Intern, ABC Technologies, Jan–Jun 2026" under Experience.
Why it matters: Many fresher job descriptions ask for 0–1 years of experience. A real internship can make your application much stronger.

Work From Office (WFO)

Professional Workplace

Simple definition: Working on-site at the company's office. Often shortened to WFO.
Example: The internship requires working from the Bengaluru office five days a week.
Why it matters: Check the work mode before accepting an offer — it affects travel, rent and your daily routine.

Workplace Culture

Professional Workplace

Simple definition: The shared values, habits and unwritten rules of how people work together in a company or team.
Example: Some teams discuss everything in open channels; others prefer one-to-one messages.
Why it matters: Watching how your team works in the first weeks helps you fit in and avoid misunderstandings.

Why Should IT Students Learn Internship Terms?

Technical knowledge alone is not enough during an internship. On your first day, you may hear that your ticket is in the sprint backlog, your PR needs another review, the build failed in CI and you should raise the blocker in stand-up — all before you have written any code.

Software teams have their own language for how they communicate, plan and track work, review code and release software. Interns who understand it can follow discussions, ask better questions and start contributing sooner. Those who don't often stay quiet and lose days that one question would have saved.

Learning these terms isn't about sounding impressive. It is about understanding what is happening around you, so your energy goes into doing the work well.

How to Use This IT Internship Glossary

Read unfamiliar terms from internship job descriptions. When a JD mentions CI/CD, REST APIs or Agile, look the terms up here and notice which ones keep appearing for your target role.
Learn the basic meaning before the internship. A rough understanding of Git, Agile and common workplace tools is enough to start. You don't need to be an expert.
Look up unfamiliar terms during onboarding. Keep this page handy in your first weeks. When you hear a new word in a meeting, check it here — or ask your mentor.
Understand how each term is used in your own project. Every company uses terms a little differently. Notice what your team means by words like "done", "release" or "environment".
Don't try to memorise every IT term. Understanding a term when you need it matters more than learning a list. Terms make sense fastest when you use them in real work.

Frequently Asked Questions

What is an IT Internship Glossary?

An IT Internship Glossary is a list of terms students commonly hear before and during an IT internship — in job descriptions, interviews, onboarding and daily team work — explained in simple language with examples. This one covers 199 terms across ten categories.

What IT terms should an intern know?

Start with the terms you will meet in your first week: Git basics (repository, branch, commit, Pull Request), Agile terms (sprint, stand-up, user story), your team's tools, and workplace words like blocker, deadline and escalation. Then learn the technical terms for your own role.

What technical terms should freshers learn?

Focus on the fundamentals that appear in most job descriptions: frontend and backend, API, database and SQL, HTTP, debugging, testing, deployment and environments. Learn what they mean in a real project rather than memorising definitions.

Do I need to know all these IT terms before an internship?

No. Nobody expects an intern to know every term. Learn the basic ones for your role before you join, and look up the rest as you meet them. Asking what a term means is completely normal in your first weeks.

Which Git terms should an IT intern know?

The everyday ones: repository, clone, branch, commit, push, pull, merge, Pull Request and merge conflict. Knowing what a README and a .gitignore file are also helps when you set up a new project.

What Agile terms should an intern understand?

Sprint, daily stand-up, sprint planning, retrospective, user story, backlog, acceptance criteria and story points, plus the roles of Scrum Master and Product Owner. Teams adapt Agile in different ways, so notice how your own team uses these words.

What workplace terms should IT students know?

Terms like blocker, dependency, escalation, deadline, deliverable, action item, ownership and constructive feedback. They describe how teams communicate and get work done, and using them correctly shows professional maturity.

How can students prepare for an IT internship?

Build a technical foundation for your target role, complete one or two real projects, learn basic Git, practise explaining your work and get familiar with common workplace terms like the ones in this glossary. The IT Internship Readiness Test can show which areas need the most attention.