TypeScript Internship
TypeScript is not JavaScript with annotations. Used properly it makes whole categories of bug impossible, and makes refactoring something you stop fearing.
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
- TypeScript
- Generics
- Zod
- React
- Node.js
- tRPC
Any is a decision, and usually the wrong one
Most codebases that “use TypeScript” are JavaScript with sprinkles. Review here checks whether your types actually describe reality, or whether you cast your way past every hard part.
- 1You start on an untyped real codebase
- 2You type it incrementally without breaking it
- 3Your mentor hunts every any and casts in review
- 4You share types between the API and the client
Weeks 1 to 2 cover JavaScript fundamentals first. Types on top of shaky JS do not help.
// Week 8: runtime validation that produces the static type const Order = z.object({ id: z.string().uuid(), status: z.enum(["pending", "paid", "shipped"]), total: z.number().positive(), placedAt: z.coerce.date(), }); export type Order = z.infer<typeof Order>; // one source of truth export async function getOrder(id: string): Promise<Order> { const res = await fetch(`/api/orders/${id}`); if (!res.ok) throw new ApiError(res.status); return Order.parse(await res.json()); // validated, not asserted }
Eight things you will actually be able to do
JavaScript first
Scope, closures, prototypes and async. The runtime types describe.
The type system
Structural typing, narrowing, unions, intersections and literal types.
Generics
Writing reusable typed utilities without reaching for any.
Advanced types
Conditional types, mapped types, template literals and utility types.
Runtime validation
Zod and parsing external data so static types match reality.
TypeScript with React
Typed props, hooks, events, refs and generic components.
Typed APIs
Sharing types across client and server so a contract change fails at build time.
Config and migration
tsconfig strictness, incremental adoption and typing a legacy codebase.
The 12-week plan
Four phases. Each one ends in a deliverable that is reviewed and graded before the next opens.
JavaScript and types
The runtime, then the type layer on top.
- JavaScript fundamentals: scope, async, modules
- Basic types, inference, unions and narrowing
- tsconfig, strict mode and the compiler
- Git, branching and pull request review
A small utility library, fully typed under strict mode, with zero uses of any.
Generics and structure
Reusable types that describe real shapes.
- Generics, constraints and inference
- Discriminated unions and exhaustive checks
- Utility types and mapped types
- Modelling domain state so invalid states cannot compile
A typed domain model where every impossible state is unrepresentable, reviewed for escape hatches.
Applied TypeScript
In the places you will actually use it.
- Typed React: props, hooks, events, generics
- Zod validation and inferring types from schemas
- Typed API clients and shared contract packages
- Typing third-party and untyped libraries
A React client and Node API sharing one type contract, where breaking it fails the build.
Scale and migrate
Bringing types to a codebase that has none.
- Incremental migration of a JavaScript project
- Declaration files, module resolution, monorepos
- Type-aware linting and CI type checks
- Portfolio case study, CV rewrite, mock interview
A real JavaScript project migrated to strict TypeScript, with CI type checking and a written report.
Every intern types a real codebase
You take an existing untyped Ezitech project and migrate it to strict TypeScript without breaking it. Then extend it with a new typed feature.
- A strict-mode codebase with no escape hatches
- Types shared between the client and the API
- A written migration report other teams can follow







What every Ezitech intern gets
Three things that make this different from a course you watch on a screen.
Live client briefs
You work on real Ezitech projects with real deadlines and real revision rounds, not recycled practice exercises.
A mentor, not a playlist
Weekly reviews with someone who does this work for a living, plus a team of interns around you to build with.
Portfolio and experience letter
You finish with shipped work you are allowed to show and a letter that says exactly what you delivered.
Verified certificate
Issued by Ezitech Institute and verifiable by employers.
Experience letter
On company letterhead, stating exactly what you delivered.
A fully typed codebase
A shipped project with end-to-end type safety and no escape hatches.
Interview preparation
CV rewrite, portfolio case study and a technical mock interview.
A route into the team
Top performers are considered first for paid junior roles.
Confidence in review
Twelve weeks of defending your own work to a senior practitioner.
Built for you if
- You already write some JavaScript and want to level up
- You are heading into React, Node or full-stack roles
- You have been bitten by a runtime error types would have caught
- You want to work on codebases larger than one file
Not a fit if
- You want a certificate without doing the work
- You cannot give 25 hours a week for 12 weeks
- You are looking for a purely theoretical course
- You want to skip review and work alone
Questions people ask
Everything applicants email us about, answered before you apply.
Should I learn JavaScript before TypeScript?
How many hours a week does it take?
Is it remote or onsite?
Is TypeScript actually required by employers?
Can final-year students apply?
How do I apply?
Not sure TypeScript is the one?
Every front-end internship runs three months, hybrid, with the same mentor model. Or take the six-month All-in-One flagship.
React JS
Component architecture, state and performance on a real product.
View trackHTML & CSS
Semantic markup, modern layout and interfaces that work everywhere.
View trackAngular
Enterprise front ends with modules, RxJS and strong structure.
View trackVue JS
Composition API, Pinia and a real product interface.
View trackRefactor without holding your breath
Three months, one shipped piece of real work, a mentor who reviews you every week. Registration takes five minutes.
Ezitech Institute · Rawalpindi, Pakistan · info@ezitech.org · +92 345 5555396