A 30-Hour AI Learning Plan for Placement Season 2026

Thirty structured hours produce one deployable AI mini-project and the interview vocabulary to explain it — no prior AI experience required, and no course purchases needed.

This plan is for the engineering student who has a placement timeline coming up and wants a concrete, scoped AI output, not a vague roadmap to “learn machine learning.” The deliverable at the end of 30 hours is a working Streamlit app that runs a real NLP task using the Hugging Face Transformers library, pushed to a public GitHub repo and deployed on Hugging Face Spaces. That URL goes on the resume. The interview vocabulary comes from understanding what you actually built.

The plan divides into four blocks: foundations (8 hours), project build (10 hours), deployment and documentation (6 hours), and interview prep (6 hours). Each block has a concrete output, not a “by the end you should understand X” goal.

---

Hours 1-8: Foundations that actually matter

Most AI learning plans front-load theory that doesn’t pay off until much later. This block skips the math deep-dives and covers the three concepts that directly support the project you’ll build in Hours 9-18.

What to cover in these 8 hours

Concept 1: What a pre-trained model is and how inference works (2 hours)

Work through Chapters 1 and 2 of the Hugging Face NLP Course (free, browser-based, no GPU needed). By the end of Chapter 2, you’ll understand: what a transformer model is at a functional level, what a pipeline does, and how to run a model on text input without knowing how the model was trained. That’s exactly what the project needs.

Concept 2: What tokenisation does (1 hour)

Still inside the Hugging Face course, Chapter 2’s tokenisation section. Tokenisation comes up in almost every AI fresher interview. Being able to say “the model converts text into tokens, which are numerical representations the model processes” — and explain that “ChatGPT” might tokenise as two or three tokens — is the kind of specific answer that distinguishes a student who built something from one who watched videos.

Concept 3: What the Hugging Face pipeline() function does (2 hours)

This is the single most important technical concept for the project block. Run the code examples in the Hugging Face course Chapter 1 interactively. Experiment with the sentiment-analysis, summarization, and question-answering pipelines using your own text inputs. Choose the one you’ll build your project around by Hour 8.

Concept 4: Fast.ai orientation (3 hours)

Watch Lesson 1 of fast.ai Practical Deep Learning for Coders (free). The goal here is not to follow every detail, but to see what a complete model training and deployment cycle looks like before you’ve built anything. Fast.ai’s lesson 1 is famous for showing a working deployed image classifier in under 2 hours. The framing (“top-down learning, deploy first”) matches what this plan does with NLP.

What to skip in Hours 1-8

Skip the math sections for now. The linear algebra and calculus content in most AI courses is important for understanding model internals, but it doesn’t change how you use a pre-trained pipeline in a Streamlit app. The 2026 AI roadmap for Indian engineering students covers where to go deeper after placement season.

Skip fine-tuning. You’re using a pre-trained model as-is. Fine-tuning is a separate skill that requires a GPU, a dataset, and considerably more time.

Output of Hours 1-8

You can explain in one sentence what your project will do, what model it uses, and roughly how the pipeline works. You’ve chosen which of the three project options to build.

---

Hours 9-18: Build the mini-project

Ten hours to go from an empty folder to a working Streamlit app running a real AI model. This block is the one that produces the resume line.

Choose your project option

Three options, ordered from simplest to most complex:

• Option A (simplest): Sentiment analysis app. The user types a review or sentence. Your app classifies it as positive or negative and shows a confidence score. Uses the sentiment-analysis pipeline from Hugging Face. The technical steps are straightforward; the output is immediately understandable to a recruiter.
• Option B (moderate): Text summariser. The user pastes a paragraph or article. Your app returns a shorter version. Uses the summarization pipeline. Requires handling longer input, which introduces some edge-case debugging.
• Option C (more complex): Simple Q&A bot. The user provides a context paragraph and asks a question. Your app extracts the answer from the paragraph. Uses the question-answering pipeline. Slightly more complex input structure, but produces a visually impressive result.

For a student with limited Python experience, Option A is the clear choice. For a student comfortable with Python, Option B or C takes the same 10 hours but produces a more visually differentiated output.

Step-by-step: Hours 9-18

Hours 9-10: Environment setup

• Install Python 3.10+ if not already present.
• Create a virtual environment: python -m venv venv.
• Install dependencies: pip install transformers streamlit torch.
• Verify the install: run python -c "from transformers import pipeline; p = pipeline('sentiment-analysis'); print(p('This works.'))". If it prints a confidence score, your environment is set up correctly.

Note: the first run downloads the model weights (roughly 250-400 MB depending on the model). This happens once. Subsequent runs use the cached weights.

Hours 11-13: Write the core pipeline logic

Create app.py. The core logic for Option A is:

from transformers import pipeline
classifier = pipeline("sentiment-analysis")

def analyse(text):
    result = classifier(text)[0]
    return result["label"], round(result["score"] * 100, 1)

Test this function independently before adding Streamlit. Pass 5-10 different inputs and check the outputs make sense.

Hours 14-16: Wrap in Streamlit

The Streamlit wrapper adds a browser-based UI without any HTML or JavaScript knowledge. For Option A:

import streamlit as st
from transformers import pipeline

st.title("Sentiment Analyser")
st.write("Type any text and get a sentiment score.")

classifier = pipeline("sentiment-analysis")
user_input = st.text_area("Enter text:", height=150)

if st.button("Analyse"):
    if user_input.strip():
        label, score = analyse(user_input)
        st.write(f"**Sentiment:** {label}")
        st.write(f"**Confidence:** {score}%")
    else:
        st.warning("Enter some text first.")

Run streamlit run app.py and test in the browser. Fix anything that breaks.

Hours 17-18: Test, handle edge cases, push to GitHub

Test with at least 10 inputs: very short text, very long text, non-English characters, empty input. Add error handling for obvious failures. Create a new public GitHub repo, push the code, and make sure the repo shows app.py and requirements.txt (run pip freeze > requirements.txt).

Output of Hours 9-18

A working app.py on a public GitHub repo. You can run it locally and demo it.

---

Hours 19-24: Deploy, document, and make it look real

Six hours to turn a local script into something you can share with a recruiter via a URL.

Deploy to Hugging Face Spaces (2 hours)

Hugging Face Spaces hosts Streamlit apps for free. Create an account, create a new Space (choose Streamlit as the SDK), and either push your repo directly via Git or upload the files through the UI. The Space auto-builds on every push.

The result is a URL like https://huggingface.co/spaces/<your-username>/<project-name>. This URL goes in your resume and GitHub README.

Hugging Face Spaces uses CPU hardware by default at no cost. For the three project options in this plan, CPU inference is fast enough for demo purposes (typically 2-5 seconds per request depending on model size).

You can also explore off-campus AI engineering roles for freshers in 2026, where a live deployed project like this makes your application stand out on the platforms that evaluate work samples.

Write a real README (2 hours)

The README is what a recruiter reads before clicking the Spaces link. Structure it as:

• What it does: One sentence.
• How it works: Two to three sentences covering the model, the library, and the interface.
• How to run locally: Three to five commands, copy-paste ready.
• Example output: One screenshot or GIF.
• What I’d improve next: Two to three honest ideas. This section signals growth mindset and is the source material for your interview answer on “how would you improve this?”

Update the resume line (1 hour)

A resume line that works: “Built a [task] app using Hugging Face Transformers and Streamlit, deployed on Hugging Face Spaces. [Link].”

Avoid vague lines like “Worked on NLP project using machine learning.” The specific tools, the deployed URL, and the task description are what get the recruiter to click.

Capture a demo GIF (1 hour)

A short GIF (3-5 seconds showing the input and output) embedded in the README makes the project immediately understandable at a glance. Use any screen recorder that exports GIF. Add it to the README with standard Markdown image syntax.

Output of Hours 19-24

A live Spaces URL, a clear README with a demo GIF, and an updated resume line.

---

Hours 25-30: Interview vocabulary from your own project

The final 6 hours are not for learning new AI concepts. They’re for building the specific language to talk about what you built.

The four questions that come up in every fresher AI project interview

Question 1: Tell me what your project does

Prepare a 60-second answer. It should cover: the problem (classifying sentiment / summarising text / answering questions from a paragraph), the technical approach (using a pre-trained transformer model via the Hugging Face pipeline), and the interface (Streamlit app deployed on Hugging Face Spaces). Practice saying this aloud until it doesn’t sound like a rehearsed script.

Question 2: Why did you choose this model

The honest answer is that you used the default model from the Hugging Face pipeline, which is a fine-tuned BERT variant for Option A, a BART or T5 variant for Option B, and a DistilBERT variant for Option C. Know the name of the model you actually used (it’s in the pipeline download logs). Being able to say “I used distilbert-base-uncased-finetuned-sst-2-english because it’s the Hugging Face default for sentiment analysis, it runs on CPU, and it performs well on English text” is a complete, honest, and impressive answer for a fresher.

Question 3: What would you change or add

This answer should already be in your README. Common improvements: add language detection and handle non-English input gracefully; allow batch processing of multiple inputs; add confidence threshold controls so the user can set a minimum confidence before the result displays; deploy a fine-tuned version on a domain-specific dataset (customer reviews, social media text, etc.).

Question 4: How would you scale this if many users hit it at once

You don’t need to know distributed systems architecture to answer this. A solid fresher answer: “The current version is a demo running a single CPU instance. For production scale, I’d move inference behind a FastAPI endpoint, cache frequent queries, and look at Hugging Face’s Inference API for managed scaling. I haven’t implemented that yet, but I understand where the bottleneck would be.” That answer is honest, shows systems thinking, and doesn’t overclaim.

Practice the answers (2 hours)

Write out your answers to all four questions. Then close the notes and speak them aloud. Record yourself if it helps. The goal is conversational fluency, not memorisation.

Output of Hours 25-30

Four clear, non-jargon answers to the standard fresher AI project questions. A vocabulary that references your specific project, not generic AI concepts.

---

Where this 30-hour plan fits in the bigger picture

This plan produces one project and interview vocabulary for one placement cycle. It is a starting point, not a ceiling.

If you’re targeting higher-tier product company roles, AI-specific teams, or off-campus opportunities, the 2026 AI roadmap for Indian engineering students maps out the six-stage curriculum that comes next: deeper ML fundamentals, fine-tuning, RAG pipelines, deployment patterns, and a second portfolio project. That roadmap covers a 4-6 month investment at 10 hours per week.

The 30-hour plan above is specifically scoped for the student who has limited time before placement season and wants a concrete, defensible output rather than a certificate.

---

The project you build in Hours 9-18 is the kind of thing that demonstrates you’ve actually shipped something with AI, not just watched videos about it. TinkerLLM is where you take the next step after that: at ₹299, it puts real LLM API calls in your hands, lets you build a second project on top of a live model, and produces the kind of output your resume needs when a recruiter asks what else you’ve built since the Streamlit app.