AI assistants can now turn a Figma frame into a working React component in the time it takes to make tea, so producing a screen has stopped being the scarce part of the job. What stays scarce sits around that screen: deciding what renders on the server and what runs in the browser, keeping the main thread free on a cheap phone, and noticing that the generated dropdown cannot be reached from a keyboard. Frameworks have also pulled server concerns into frontend work, which thins the line between browser code and backend code. The front end developer skills worth paying for have moved accordingly.
Below you will find seven core skills, each with a check you can run while hiring, then the working habits that make someone easy to build with, what has gained and lost weight, a matrix by level, and an assessment process that keeps framework trivia out of the room.
Core technical skills for a frontend developer
TypeScript used to model the product
Adding annotations is easy. The valuable skill is shaping types so that impossible states cannot compile: a request is loading, failed or loaded, never two at once, and API data gets parsed at the boundary before the app trusts it. How to check it: show a component holding separate isLoading, error and data flags, and ask for a type that stops a screen being both loading and failed. Then ask what happens if the server sends null in a field the type promises is a string. Good candidates know types vanish at build time and mention runtime validation with a library such as Zod.
Rendering strategy
Next.js, Nuxt and Angular’s server rendering all offer static pages, server rendering and client rendering inside one app. Strong developers choose route by route, understand what hydration costs, and can say where React Server Components help and where they add confusion. How to check it: describe a marketing page, a product listing and a logged-in account screen from one product. Ask how each should render and what may be cached. Listen for a warning about one customer’s data landing in a shared cache.
Forms and long-running flows
Long forms are where frontend bugs start costing money. The work covers validation in the browser and again on the server, drafts that survive a refresh, sessions that expire halfway and retries that must not create a second order. How to check it: describe a multi-step loan application, then ask what the user should see when the session expires on the final step, and what happens if they press Back after submitting. Strong candidates talk about preserved input, focus moving to the first error and agreeing an idempotency key with the backend team.
Modern CSS and layouts that survive real content
Tailwind CSS speeds up styling, but it does not replace an understanding of the cascade, stacking contexts or grid. Container queries let a component respond to its own space instead of the viewport, and logical properties make right-to-left support far cheaper to add. How to check it: take a finished component, swap its labels for long translated strings and raise the browser’s text size. Ask the candidate to predict what will break before they look, then fix it.
Runtime performance in the field
Core Web Vitals are LCP, INP and CLS, and what counts is how they behave for real visitors. Good developers read field data, hunt long tasks on the main thread and know what analytics tags and chat widgets cost. How to check it: say Lighthouse gives the checkout page a healthy score while field data shows poor INP, then ask how both can be true. A strong answer notes that a lab run never clicks anything and tests one fixed device profile, then moves on to third-party scripts, heavy event handlers and breaking up long tasks.
Accessibility beyond the automated scan
Tools such as axe catch missing labels and weak contrast, but they cannot tell whether an announcement helps anyone. WCAG 2.2 is the working reference, and the European Accessibility Act now covers many consumer digital services sold into the EU, which reaches Indian companies with customers there. How to check it: say the checkout passes an automated scan with no errors, then ask what could still fail a real user. Look for validation messages that are never announced, focus lost after a modal closes, and link text that only makes sense to someone who can see the page.
Browser security and dependency care
Frontend code handles tokens, renders user content and pulls in hundreds of packages, and npm supply chain attacks are a regular event. Good developers understand cross-site scripting, what a Content Security Policy does and why a long-lived token in localStorage is a risk. How to check it: show a profile page that injects a user’s bio through dangerouslySetInnerHTML while an access token sits in localStorage. Ask what an attacker could do and what they would change. Then ask how they decide whether a new package deserves a place in the bundle.
Working skills that separate good from average
- Challenging a design while it is still cheap. Strong developers join design reviews and raise the missing empty state or the drag gesture with no keyboard alternative, bringing a suggestion along with the objection.
- Shaping the API alongside backend developers. They ask about pagination, error formats and partial failure before any code exists, so the screen does not have to work around a response nobody questioned.
- Watching what happens after release. Good developers check error monitoring in Sentry or a similar tool, look at where users drop off and follow up on their own feature without being asked.
- Keeping upgrades boring. Major framework versions arrive whether or not a team is ready. The people worth keeping break an upgrade into small steps, use codemods where they exist and explain the cost to product managers in plain terms.
What counts for more in 2026, and what counts for less
Mattering more. Reviewing generated interface code has become a daily task, because assistants write plausible components that skip keyboard support, duplicate something already in the design system or add a package nobody needed. Server-side knowledge carries more weight now that Server Components and framework data loading put caching and authentication decisions in frontend hands. Clean design tokens and well-documented components pay off twice, since AI tools produce far better output from a tidy system. Products with LLM features also need interfaces for streamed text, cancelled requests and answers that turn out to be wrong, which is new territory for many teams.
Mattering less. Hand-placed memoisation matters less in React codebases that have adopted the React Compiler. Writing Webpack configuration by hand is rarer, as Vite and framework tooling cover most needs, and Create React App is deprecated. Memorising framework syntax also counts for little when an assistant can recall it, so interview time is better spent on reasoning and debugging.
Frontend skills matrix by level
| Skill area | Junior | Mid-level | Senior |
|---|---|---|---|
| TypeScript | Types props and API responses correctly | Models states so bad ones cannot compile | Sets strictness rules and shared types |
| Rendering | Knows client from server rendering | Chooses a strategy per route | Sets caching and rendering policy for the app |
| Components | Uses the library as designed | Builds reusable, composable components | Owns the library and its migration paths |
| CSS and layout | Builds responsive pages with flexbox and grid | Handles long content and text resizing | Defines tokens and styling conventions |
| Performance | Optimises images and avoids obvious waste | Finds long tasks using field data | Sets budgets and governs third-party scripts |
| Accessibility | Writes semantic HTML with labels | Tests by keyboard and screen reader | Makes it part of definition of done |
| Security | Avoids rendering raw user HTML | Handles tokens and sessions safely | Sets policy for packages and CSP |
How to assess frontend skills when hiring
Most frontend CVs read alike, so give candidates something closer to a working day than a quiz. Once the frontend developer job description is settled, build the process from the steps below and have someone who writes frontend code run the technical parts.
- Review generated code together. Hand over a component written by an assistant, with an accessibility gap, a needless dependency and a duplicate of something in your library. The review shows whether they read code or accept it.
- Stabilise a flaky test. Share a Playwright test that selects by CSS class and waits on a fixed timer. Ask why it fails now and then, and how they would rewrite it around roles and visible state.
- Change their own work. If you set a take-home, add a new requirement in the follow-up and watch them extend the code. This is hard to fake and quickly exposes work the candidate did not write.
Red flags on a CV: React, Angular, Vue and Svelte claimed at equal depth; “pixel perfect” offered as the main achievement; performance work with no metric named; a perfect Lighthouse score quoted as proof of speed; and projects that are all cloned to-do or weather apps.
Frequently asked questions
Can an Angular developer move to a React team?
Usually yes, because the browser fundamentals and TypeScript carry across. Expect some time spent unlearning, since Angular provides routing, forms and dependency injection out of the box, while a React team assembles those choices. Test the fundamentals and be open about the learning period.
How much backend should a frontend developer know in 2026?
Enough to read an API contract, understand HTTP caching and authentication, and reason about what a server component does. On Next.js or Nuxt, that knowledge is part of the daily work. Designing database schemas and running services remains a different job.
Should candidates be allowed AI assistants in a frontend test?
Allow them if your team uses them, and judge what happens next. Ask the candidate to explain the output, name what they changed and say what they tested. Someone who can do that has shown more than someone who typed from memory under observation.
Does a frontend developer need to know Figma?
They need to read it well: inspect spacing, understand components and variables, and spot where a design has missed a state. Producing designs from scratch is not expected, and asking for it usually means the team has a designer gap to fill.
For a redesign, a launch or a long-term owner of the frontend, you can hire frontend developers in India through Zilo AI on contract, contract-to-hire or permanent terms. Full stack, backend and QA roles sit on the same IT hiring page if the product needs a wider team. Tell us which framework you run and what the next release has to do.