Part of our guide hub: IT internships
Most people learning web development stall in the same place: they can follow a tutorial, but cannot start a project from an empty folder. The fix is not more tutorials. It is a sequence with deadlines and something real at the end of it.
This is the shape of the plan we run internally, written so you can follow it whether or not you join a programme.
Weeks 1 to 2: The foundation people skip
HTML that means something and CSS you actually understand. Not a framework. The underlying model.
- Semantic elements, and why a div is not a button
- The box model, and how margin collapsing really behaves
- Flexbox and Grid until you can build a layout without searching
- Responsive design with real breakpoints, tested on a phone
- Basic accessibility: labels, focus states, alt text, colour contrast
Deliverable: rebuild a page from a site you admire, from scratch, no framework, responsive.
Weeks 3 to 4: JavaScript, properly
This is where the career is made or stalled.
- Types, scope, closures. Enough to reason about them
- Array methods until map, filter and reduce are automatic
- DOM manipulation and events, including delegation
- Async: callbacks to promises to async/await, and why it exists
- fetch, JSON, and (critically), handling errors and loading states
Deliverable: an app that consumes a public API with proper loading, empty and error states. Those three states are what separate a student project from a professional one.
Weeks 5 to 6: A framework, and only one
React, Vue or Angular. The choice matters far less than depth. Components, props, state, lists and keys, side effects, forms and validation, routing, and one honest attempt at shared state.
Deliverable: a multi-page app with routing and forms that survives a page refresh.
Weeks 7 to 8: The backend half
Frontend-only developers hit a ceiling fast. You need enough backend to be dangerous.
- A server framework: Node with Express, or Laravel if you are on PHP
- REST endpoints and correct status codes
- A real database: schema design, relationships, indexes, and SQL by hand before an ORM
- Authentication with sessions or JWT, password hashing, and why you never store plain text
- Validating every input on the server, regardless of frontend validation
Deliverable: your own API, consumed by your own frontend.
Weeks 9 to 10: Ship it
Deployment is where most self-taught developers have a gap, and employers know it.
- Git branching and pull requests as a habit
- Environment variables and never committing secrets
- Deploying frontend and backend, with a managed database
- A custom domain and HTTPS
- Basic CI: run tests on push
Deliverable: a live URL you can send to anyone.
Weeks 11 to 12: Make it employable
- Performance: image sizing, lazy loading, bundle size, Core Web Vitals
- Security basics: XSS, CSRF, SQL injection, rate limiting
- A README that states the problem, the stack, the decisions and the trade-offs
- Three minutes of practised explanation of your project, out loud
Four rules that matter more than the curriculum
- Build without the tutorial open. The discomfort is the learning. If you can only code along, you cannot code.
- One project, twelve weeks. Depth beats a portfolio of five half-finished clones. Employers read one project carefully.
- Read errors properly. The stack trace usually contains the answer. Developing that reflex is worth more than a framework.
- Get your code reviewed. This is the single largest advantage of a real internship over self-study. Someone senior telling you why your approach will hurt in six months.
What a good internship adds
The curriculum above is freely available. What a structured programme provides is deadlines, code review, a real codebase with other people’s conventions in it, and exposure to the parts nobody teaches: estimating work, handling a changed requirement, and shipping something a client will actually use.
Ezitech runs hybrid web development internships in Rawalpindi with mentored code review on live client projects. See current tracks and apply.