Source: Derived from Resources/Intern_dev_assessment.pdf — a multi-track intern hiring assessment bundle (a single document offering four role-specific take-homes: a React Native Frontend assessment, a Python Backend LLM assessment, and a Java Backend assessment). The format (public GitHub repo, README, deploy to a public server, "Brownie Points" bonuses) matches the take-home style used by Indian product/startup engineering teams hiring SDE interns.
useState, useEffect), FlatList/SectionList rendering, navigation between screens (React Navigation — stack navigator), controlled text input for a search bar, debounced search, image rendering (movie posters), fetch/Axios to a public REST API, and local persistence with AsyncStorage.asyncpg, SQLAlchemy async); modeling for heavy INSERT/DELETE throughput.README.md, unit tests, Git/GitHub hygiene, Docker/containerized builds, and deployment to a public server (Render, Railway, Fly.io, a cloud VM, etc.).curl requests, and reproducible run steps.A student should be comfortable in at least one of the three stacks (React Native + JS, Python + FastAPI, or Java + Spring Boot) and understand the universal idea of a REST API: a client sends HTTP requests, a server processes them, talks to a database, and returns JSON with appropriate status codes. For the mobile track they need React fundamentals (components, props, state, Hooks) plus how to call a public API and render lists/images. For the FastAPI track they need async Python, basic database modeling, and the conceptual model of calling an LLM through an HTTP API with a prompt. No deep ML knowledge is required — the LLM is consumed as a black-box service. Familiarity with Git/GitHub, writing a README, and deploying to a free hosting tier is expected throughout, since every track requires a public repo and (for backends) a public deployment.
This is a pick-your-track intern assessment: candidates complete one role-specific take-home and submit it as a public GitHub repo with a clear README. The React Native track builds a Movie Search mobile app on the OMDb API. The Python Backend LLM track builds a FastAPI Chat Summarization & Insights API that ingests, stores, retrieves, and LLM-summarizes conversations under heavy CRUD load. The Java Backend track builds a referral-tracking signup API where a referral only counts as "successful" once the referred user completes their profile.
> Submission rules apply to every track: create a public GitHub repository, add a clear README with build/run instructions, and (for backend tracks) deploy to a public server or provide a Dockerized build and share a sample curl request.
Objective: Build a Movie Search mobile app in React Native (Android or iOS) using a public API.
Problem statement: A user wants to search for movies and read about them — viewing ratings, poster, and details.
Requirements:
https://www.omdbapi.com/) to fetch movie data.Bonus:
Problem description: Build a FastAPI REST API that processes user chat data, stores conversations in a database, and generates summaries & insights using an LLM-powered summarization model. It must support real-time chat ingestion (store raw messages), conversation retrieval & filtering (by user, date, or keywords), and LLM-based summarization. It must be optimized for heavy CRUD operations with efficient query handling, use a database of your choice (MongoDB / any NoSQL preferred for scalability, or MySQL/PostgreSQL), and implement proper error handling with meaningful status codes.
Expected API endpoints:
POST /chats — Store chat messages (heavy INSERT).GET /chats/{conversation_id} — Retrieve chats (heavy SELECT).POST /chats/summarize — Summarize a chat via LLM.GET /users/{user_id}/chats?page=1&limit=10 — Get a user's chat history (paginated for heavy load).DELETE /chats/{conversation_id} — Delete a chat (heavy DELETE).Deployment notes: Deploy on a public server or provide a Dockerized build; store code in GitHub with clear setup instructions.
Coding guidelines: Follow FastAPI best practices; use async DB queries for scalability; implement indexing & optimized queries for heavy SELECTs; provide a README.md with install & usage; keep code modular and documented; use an LLM of your choice via its API.
Brownie points:
Problem description: Create an API for user signup with referral-code tracking, where a referral counts as successful only after the referred user completes their profile. (Example: if user A signs up with user B's referral code, the referral is successful only once A completes their profile.)
Expected output:
Deployment notes: Deploy on a public server, share the GitHub repo and a sample curl request; choose your own tools (SQL/NoSQL, cloud provider, etc.).
Coding guidelines: Clean, readable code with meaningful comments, a comprehensive README, and unit tests.
Brownie points: An endpoint that generates a report of all users and their referrals in CSV format.
FlatList of results showing poster and title, plus loading and "no results found" states. Skip navigation and persistence entirely. The learning goal is mastering the core loop — controlled input → fetch to a public API → parse JSON → render a list of cards with remote images — and handling the three states every API screen needs (loading, empty, error). This is the right entry point for a student who has never wired a real network call into a mobile UI.POST /chats, GET /chats/{conversation_id}, and GET /users/{user_id}/chats?page=1&limit=10 backed by SQLite or MongoDB, with Pydantic models, proper status codes, and pagination. The goal is to internalize REST CRUD, request validation, and pagination before adding any AI. Once it works, add a single POST /chats/summarize endpoint that concatenates a conversation and returns a naive non-LLM summary (e.g., first + last message and a message count) so the contract is in place for a future LLM swap.POST /chats/summarize, and one insights feature (sentiment or keyword extraction). Add a Dockerfile and deploy to a free tier (Render/Railway/Fly.io). The learning goal is realistic backend engineering under a performance constraint — designing indexes for heavy reads, doing async I/O so LLM latency doesn't block the event loop, and treating the LLM as an external dependency with timeouts and error handling.summarize, extract_action_items, detect_sentiment, flag_followups — and composes a structured insights report. Persist conversations in a vector store so the agent can answer follow-up questions like "what did this user complain about last week?" via retrieval (RAG). Expose it through FastAPI with a streaming WebSocket endpoint and a Streamlit chat UI. The goal is hands-on agentic-AI engineering: tool definitions, an orchestration loop, retrieval grounding, and streaming output — a direct ladder from "call an LLM once" to "build an autonomous, tool-using agent."