Frontend Developer (Nigeria)

Talent Hackers, LLC; United States; Remote; USD 110,000 - 160,000; Full time

Job summary

Talent Hackers, LLC is seeking a Frontend Engineer to build resilient, responsive user interfaces and high-performance web applications. You will implement interfaces from Figma, create a reusable component library, and ensure accessibility across devices and browsers.

You will work with REST/GraphQL APIs, optimize Core Web Vitals, and collaborate with backend teams to deliver robust frontend solutions.

Qualifications

• 3+ years of frontend engineering experience.
• Proficient in semantic HTML and CSS.
• Production experience with TypeScript/JavaScript.
• Experience consuming REST or GraphQL APIs.
• Knowledge of Core Web Vitals and web performance.

Responsibilities

• Implement interfaces from designs in Figma and ensure accessibility.
• Build reusable component library and establish frontend conventions.
• Integrate frontend with APIs, handle data fetching and errors.
• Optimize performance and ensure cross-browser compatibility.

Skills

Frontend engineering

HTML/CSS

TypeScript

REST/GraphQL APIs

Web performance

Accessibility WCAG

Tools

Vite

Webpack

Playwright

Testing Library

Job description

Job Overview

We’re looking for a Frontend Engineer to build resilient, responsive user interfaces and deliver high-performance web applications. The ideal candidate combines deep expertise in semantic HTML, CSS, TypeScript, and modern frontend frameworks (such as React, Vue, or Svelte) with strong capabilities in API integration, web performance optimization (Core Web Vitals), and web accessibility (WCAG). This role will collaborate closely with engineering leads and backend developers, establish reusable component libraries and architectural standards, and ensure seamless, high-quality user experiences across all devices and edge cases.

Core Tasks

1. Interface implementation

• Build the screens and flows in scope from designs in Figma (or similar), matching them faithfully and raising the cases the designs do not cover.
• Write semantic HTML and maintainable CSS: responsive across target breakpoints / devices, correct across target browsers, and holding up as content changes.
• Handle the states that get skipped — loading, empty, error, partial data, long strings, slow networks — so the interface behaves when conditions are not ideal.
• Meet WCAG 2.1 AA / stated accessibility expectations: keyboard navigation, focus management, labeling, and contrast.

2. Component library and frontend architecture

• Build a reusable component library in framework, e.g., React, Vue, Svelte with TypeScript types, so the next developer is composing rather than rewriting.
• Establish and document the frontend conventions: file structure, state management approach, styling approach, naming, and testing strategy.
• Keep the component API small and predictable; document each component's props and intended use.

3. Exercising the API

• Integrate the frontend with the team’s API: authentication, data fetching, caching, optimistic updates, pagination, and error handling.
• Exercise endpoints against real responses during development — surface gaps, ambiguities, and awkward payload shapes to the backend team early, while they are still cheap to change.
• Type API responses end to end so contract changes fail at build time rather than in production.

4. Web optimization

• Establish performance baselines and hit agreed targets for Core Web Vitals: LCP, INP, CLS on target devices and connection profile.
• Reduce bundle size through code splitting, lazy loading, and dependency discipline; justify every heavy dependency added.
• Optimize asset delivery: image formats and sizing, font loading strategy, caching headers, critical CSS.
• Add performance measurement to CI or the deploy process so regressions are caught before release, not after.

Deliverables

• Production-deployed frontend covering the agreed scope of screens and flows.
• Documented, typed component library with usage examples.
• Written frontend conventions: architecture, state management, styling, and testing approach.
• Automated tests running in CI.
• Accessibility audit results against WCAG 2.1 AA / stated with issues resolved or documented.
• Performance report showing baselines and final numbers against the agreed targets, plus the measurement setup that produced them.
• Cross-browser and responsive verification across target browsers and breakpoints.
• Handoff package: architecture notes, known limitations, and a walkthrough session with the team.

Must Haves

• 3+ years of frontend engineering experience
• HTML and CSS — core, not assumed. You write semantic markup and CSS that stays maintainable past the first sprint, and you can build a responsive layout without reaching for a framework to do it for you.
• TypeScript and JavaScript — production experience with modern JavaScript and with TypeScript used to prevent real bugs, not to satisfy a linter.
• Exercising APIs — you are comfortable consuming REST or GraphQL APIs, handling their failure modes, and giving backend engineers useful feedback about what is hard to consume.
• Web optimization — you can profile a slow page, identify the actual cause, and fix it; you know what moves Core Web Vitals and what does not.
• At least one frontend framework — depth in React / Vue / Svelte / Angular or comparable. Which one matters less than knowing why it behaves the way it does.

Nice to Haves

• Accessibility experience beyond automated checks — screen reader testing, focus management, ARIA used correctly and sparingly.
• Experience working directly from Figma (or similar) design files and collaborating with designers on the gaps.
• Familiarity with build tooling, e.g., Vite, Webpack and frontend testing tools such as Playwright, Testing Library.
• Prior contract work where you owned a frontend scope and delivered it independently.

How we will work together

• You report to the Architect / Engineering Lead and coordinate directly with the backend engineer on API contracts.
• Written status update at the close of each week: what shipped, what is at risk, what you need.
• Code is reviewed by project lead before merge; you work in team’s repository and follow its conventions.
• Tooling: repo host, project tracker, chat, design files, staging environment access.