AI Engineer In 10 Weeks | Week 2: AI Portfolio Project Review & The Reality of Competition
This chapter reviews the Week 2 milestone project: the AI Portfolio Representative. It addresses the psychological illusion of high competition in the tech industry, analyzes real-world implementations built by students, provides critical technical feedback on performance bottlenecks (such as streaming and PDF parsing), and outlines the transition from basic LLM wrapper development to advanced AI engineering.
1. The Illusion of Competition in Tech
Many aspiring engineers in highly populated regions fall into the trap of believing that the job market is too saturated to break into. This creates a psychological barrier to entry. However, a look at actual data reveals a massive gap between passive consumers and active builders.
The 1% Rule of Action
To understand the actual competition, consider the funnel of engagement for this project:
This represents a conversion rate of less than 0.5%. The remaining 99.5% of individuals are passive observers who watch videos, buy courses, or ask for notes without ever writing code.
The UPSC Analogy
Real-World Analogy: Think of the UPSC (civil services) exams. While nearly 1 million candidates apply and sit for the exam, only about 10,000 candidates are actually prepared and studying seriously. The rest constitute the "crowd" (भीड़)—individuals who participate in the process but do not represent actual competition because they lack execution.
In AI engineering, your competition is not the 80,000 subscribers; it is only the 25 people who built and deployed the project.
2. The Passive Learner Trap vs. The Builder Mindset
A common pitfall for students is seeking shortcuts, such as asking for ready-made notes, copy-pasting code repositories, or endlessly debating theoretical roadmaps (e.g., "Should I learn C++ or Java in my 3rd year?").
The "Hanuman Chalisa" Analogy
When students in their final years of university ask abstract, non-actionable questions instead of building projects, the creator jokingly suggests they should start reciting prayers (like the Hanuman Chalisa) for divine intervention. No roadmap, course, or mentor can help a student who refuses to build.
The Danger of "Copy-Paste" Learning
If you ask for code links just to clone and run them, you learn nothing. Recruiters easily spot candidates who cannot explain the underlying architecture of their projects. True learning happens when you face bugs, handle deployment failures, and optimize latency.
3. Core Architecture of an AI Portfolio Representative
The AI Portfolio Representative is a specialized chatbot trained on a candidate's resume, projects, and professional background. It acts as an autonomous agent that recruiters (HRs) can query to evaluate the candidate's fit for a role.
The Standard Interaction Flow
4. Comprehensive Project Reviews & Technical Feedback
Twelve student projects were reviewed, showcasing diverse UI/UX designs, feature sets, and backend integrations. Below is a synthesized analysis of their implementations, highlighting standout features and areas for improvement.
5. Crucial Technical Pitfalls & Optimization Strategies
During the reviews, three major technical bottlenecks were identified. Below are the architectural solutions to resolve them.
Pitfall 1: High Latency due to Lack of Streaming
When an LLM generates a response, it takes time to complete the entire paragraph. Without streaming, the user sees a static loading spinner for 10 to 20 seconds. In an era of short attention spans (driven by social media reels), users will close the tab.
Solution: Implement Server-Sent Events (SSE) / Streaming
By setting stream=True in your LLM API call, you can stream chunks of text to the frontend as they are generated.
# Example: FastAPI Streaming Implementation using OpenAI
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from openai import OpenAI
app = FastAPI()
client = OpenAI()
async def event_generator(user_prompt: str, system_prompt: str):
response = client.chat.completions.create(
model="gpt-4o-mini",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
stream=True # Crucial parameter
)
for chunk in response:
content = chunk.choices[0].delta.content
if content:
yield f"data: {content}\n\n"
@app.get("/chat/stream")
def chat_stream(prompt: str):
system_info = "You are an AI assistant representing John Doe, an AI Engineer..."
return StreamingResponse(
event_generator(prompt, system_info),
media_type="text/event-stream"
)
Pitfall 2: The PDF Re-Parsing Bottleneck
In Shubham's project, response times exceeded one minute. This occurs when the backend programmatically reads, loads, and parses the raw PDF resume on every single user query.
Solution: Parse Once, Store Locally
Do not parse the PDF dynamically during the request-response cycle. Instead, parse the resume once during build time or deployment, save the extracted text into a static JSON, Markdown, or text file, and load that file into memory when the server starts.
# Optimized Approach: Load pre-parsed resume into memory on startup
import json
from fastapi import FastAPI
app = FastAPI()
# Load the pre-parsed resume once when the server boots up
with open("parsed_resume.json", "r") as f:
RESUME_DATA = json.load(f)
@app.get("/ask")
def ask_ai(query: str):
# Directly use RESUME_DATA without any PDF parsing overhead
prompt = f"Resume Context: {RESUME_DATA}\nUser Query: {query}"
# Call LLM...
return {"response": "..."}
Pitfall 3: Cold Starts on Free Hosting Tiers (e.g., Render)
Free hosting platforms like Render spin down web services after periods of inactivity. When a recruiter clicks your link, they may experience a 30-second delay just for the server to wake up.
Solution:
- Keep-Alive Cron Job: Use a free pinging service (like UptimeRobot) to send an HTTP request to your backend every 14 minutes to keep the container active.
- Static Frontend + Serverless Backend: Host your frontend on Vercel or Netlify (which have zero cold starts) and use serverless functions or lightweight edge runtimes for your backend API.
6. Enhancing LLM Context: The "Soft Skills" Context File
A common issue across multiple projects was the AI's inability to answer standard HR questions (e.g., "What are your weaknesses?", "What are your salary expectations?", "Are you willing to relocate?"). Resumes typically do not contain this information, leading the LLM to reply with "I do not have enough information."
The Solution: The Dual-File Context Strategy
Provide your LLM with two distinct sources of context:
resume.json: Contains structured technical data (skills, projects, work history).personal_faq.txt: A conversational document containing answers to common behavioral and HR questions.
Example personal_faq.txt Structure:
[STRENGTHS]
- Highly adaptable; quick to learn new frameworks (as shown by building this AI portfolio in 1 week).
- Strong communication skills; able to explain technical AI concepts to non-technical stakeholders.
[WEAKNESSES]
- Sometimes spends too much time optimizing code for minor performance gains, but learning to prioritize shipping MVP first.
[PREFERENCES]
- Location: Open to remote roles or relocation to Bangalore/Mumbai.
- Availability: Can join immediately.
By feeding both files into the system prompt, your AI representative becomes fully equipped to handle both technical evaluations and behavioral screenings.
7. Transitioning to Advanced AI Engineering
The tools and techniques used in Week 2 (system prompts, JSON formatting, basic API wrappers, and streaming) fall under LLM Wrapper Engineering or Prompt Engineering.
Starting in Week 3, the course transitions into Core AI Engineering, introducing complex, production-grade architectures:
Upcoming Core Concepts:
- Retrieval-Augmented Generation (RAG): Dynamically searching and injecting relevant document chunks into the prompt instead of passing entire files.
- Vector Databases: Storing and querying high-dimensional embeddings for semantic search.
- LangChain & LangGraph: Building stateful, multi-step agentic workflows.
Summary and Key Takeaways
- The Competition is Minimal: Out of tens of thousands of learners, only a tiny fraction (less than 1%) actually build and deploy projects. Your real competition is incredibly small.
- Execution Beats Consumption: Watching tutorials and collecting notes will not secure a job. Building, debugging, and deploying unique projects is what sets you apart.
- Streaming is Mandatory: Always use
stream=Truefor LLM integrations to reduce perceived latency and keep users engaged. - Do Not Parse PDFs on the Fly: Parse your resume once, save it as a static text/JSON file, and load it into memory on server startup to avoid massive latency bottlenecks.
- Implement Guardrails: Ensure your AI representative is programmed to be honest (e.g., admitting when a skill is missing) rather than hallucinating false qualifications.
- Enrich the Context: Combine your technical resume with a conversational HR FAQ document to prepare your AI representative for behavioral questions.
- Aesthetics Matter: A highly polished, unique UI (such as Saurav's macOS-style interface) immediately captures a recruiter's attention and serves as a powerful differentiator.