Intake open · 3-month track

TypeScript Internship

TypeScript is not JavaScript with annotations. Used properly it makes whole categories of bug impossible, and makes refactoring something you stop fearing.

3Months
HybridFormat
356+Enrolled
FreeTo apply
app.ezitech.org/types
Your capstone buildTypes: check
Type coverage98.4%
Catches bugs
Before runtime
Mentor review
Weekly, 1-to-1
  • 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
12Weeks
25 hrsPer week
356+Interns trained
1Typed codebase
The work

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.

src/lib/api-client.ts
// 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
}
Skills

Eight things you will actually be able to do

01

JavaScript first

Scope, closures, prototypes and async. The runtime types describe.

02

The type system

Structural typing, narrowing, unions, intersections and literal types.

03

Generics

Writing reusable typed utilities without reaching for any.

04

Advanced types

Conditional types, mapped types, template literals and utility types.

05

Runtime validation

Zod and parsing external data so static types match reality.

06

TypeScript with React

Typed props, hooks, events, refs and generic components.

07

Typed APIs

Sharing types across client and server so a contract change fails at build time.

08

Config and migration

tsconfig strictness, incremental adoption and typing a legacy codebase.

Curriculum

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
Deliverable

A small utility library, fully typed under strict mode, with zero uses of any.

The capstone

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
Start your application
Ezitech seminar session with students at a university auditorium
Ezitech stall at a university open house and job fair
Ezitech receiving a shield at a university project presentation
Ezitech team and interns group photo outside the institute
Ezitech speaker presenting at a talent award ceremony
Ezitech mentors reviewing intern project documents
Ezitech team discussing an intern project brief in the office
01 / 07
Duration12 weeks
Commitment25 hrs / week
FormatOnsite + remote
LocationRawalpindi, PK
LevelJunior / fresher
ReviewsWeekly, 1-to-1
The Ezitech model

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.

And you leave with
  • 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
FAQ

Questions people ask

Everything applicants email us about, answered before you apply.

Still not sure?

Talk to the admissions team before you commit twelve weeks.

Contact Ezitech
Should I learn JavaScript before TypeScript?
Yes, and this track builds that in. Weeks 1 to 2 cover JavaScript fundamentals, because types describe runtime behaviour: if the runtime model is unclear, the type errors will be meaningless.
How many hours a week does it take?
A minimum of 25 hours across 12 weeks, split between onsite sessions, mentor reviews and independent work. Interns who treat it as full-time finish with noticeably stronger portfolios.
Is it remote or onsite?
Hybrid. Onsite days run at the Ezitech office in Rawalpindi; the rest of the week is remote with scheduled check-ins. Candidates outside Rawalpindi and Islamabad can complete the track fully remotely if they attend the weekly review calls.
Is TypeScript actually required by employers?
For most new React, Node and Angular work, yes. Job listings increasingly assume it, and existing codebases are migrating. It is one of the highest-leverage additions to a JavaScript developer’s CV right now.
Can final-year students apply?
Yes, and many do. The capstone is regularly used as a final-year project because it is built from a real brief with real requirements. Agree the scope with your mentor in week one if your university has a set submission format.
How do I apply?
Register on the Ezitech intern portal, choose the TypeScript track, and complete the three-step form with your education details and CV. Shortlisted candidates get a short screening call before the intake starts.
Applications open

Refactor 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