TypeScript developer job description template (2026)
A TypeScript developer job description you can copy, written for teams that want type safety across the whole stack, plus levels, tips and FAQs.
By the Ryz Labs team · Updated October 2026
A TypeScript developer job description should explain why you are hiring for the type system and not just for a framework. Almost every JavaScript team now writes TypeScript, so a post that only says "TypeScript required" says very little. Hire specifically for TypeScript when the work involves end-to-end type safety between front end and back end, a strict-mode migration, shared types in a monorepo, a public SDK, or a codebase where slow type checking and any creep have become real problems. The template below targets a senior TypeScript developer who owns type architecture across a full-stack TypeScript codebase.
TypeScript developer job description template
Job title
Senior TypeScript Developer (Full-Stack Type Safety)
Employment type: full-time or contract. Location: remote, with at least four hours of overlap with US Eastern time.
About the role
We are looking for a senior TypeScript developer to own the type architecture of [product name]. Our web app and API are written in TypeScript in a [pnpm / Nx / Turborepo] monorepo, and we want types that catch bugs at the boundaries: API contracts, database rows, events and forms. You will build features across the stack, lead our move to stricter compiler settings, and make shared packages easy for other engineers to use correctly. You will join a team of [number] engineers and report to [title].
Responsibilities
- Design shared types and packages used by our front end, API and background workers, with clear public interfaces.
- Build typed API contracts with [tRPC / OpenAPI-generated clients / GraphQL Codegen] so client and server stay in sync.
- Validate untrusted input at runtime with Zod or Valibot and derive static types from those schemas instead of duplicating them.
- Lead the rollout of stricter settings, including
strict, noUncheckedIndexedAccess and exactOptionalPropertyTypes, package by package. - Remove unsafe
any, unchecked type assertions and non-null assertions, and add lint rules that prevent them from returning. - Keep type checking fast with project references, incremental builds and careful use of complex conditional types.
- Build product features in [React / Next.js] and [Node.js / NestJS / Fastify], using the types you design.
- Model domain states with discriminated unions so impossible states cannot be represented.
- Write tests with Vitest, including type-level tests with expectTypeOf or tsd for shared utilities.
- Review pull requests for type design and teach the team when a simple type is better than a clever one.
Requirements
- 5+ years of professional software development, with at least 3 years writing production TypeScript.
- Strong command of generics, conditional types, mapped types, template literal types and type narrowing.
- Clear understanding of structural typing, variance and where TypeScript's type system is unsound in practice.
- Experience with runtime validation at boundaries using Zod, Valibot, io-ts or a similar library.
- Production experience on both sides of a typed API, ideally a React front end and a Node.js back end.
- Working knowledge of tsconfig options, module resolution (including
bundler and nodenext) and ES module output. - Experience in a monorepo with shared packages, project references or build orchestration.
- Experience with typescript-eslint and with writing tests in a CI pipeline.
- Clear written English for pull requests, design docs and async communication.
Nice to have
- Experience migrating a large JavaScript codebase to TypeScript, or from loose to strict mode.
- Authoring a published npm library or SDK with clean declaration files.
- Typed database access with Prisma, Drizzle or Kysely.
- Diagnosing slow type checking with
--extendedDiagnostics or --generateTrace. - Following the native TypeScript compiler port and planning for its adoption.
- Effect, fp-ts or other libraries that push typed error handling further.
Tech stack
TypeScript 5.x (strict), Node.js 22 LTS, Fastify, tRPC, Zod, Drizzle ORM, Postgres, React 19, Next.js, pnpm workspaces, Turborepo, Vitest, typescript-eslint, GitHub Actions, AWS. Replace this list with your real stack; candidates read it closely.
What success looks like in 6 months
- Our main packages compile under strict settings, and the count of
any and unchecked assertions is going down, tracked in CI. - A change to an API response type now breaks the build in every place that uses it, before it reaches production.
- Type checking in CI and in the editor is noticeably faster, measured against your own baseline.
- You have shipped features across front end and back end and written a short guide on our type conventions.
How to apply and interview process
Send your resume or LinkedIn profile and a short note about a type design you are proud of, or one you would undo. Our process has four steps: a 30-minute intro call, a technical conversation about a TypeScript codebase you have worked on, a practical exercise or pairing session that involves typing a real API boundary, and a final conversation with the team you would join. We aim to give feedback within a few days of each step.
Junior vs mid vs senior TypeScript developer
Most developers can add annotations. Seniority in TypeScript shows in how types are designed for other people to use and how safely data crosses system boundaries.
| Level | Scope | Typical experience | Key skills |
|---|
| Junior | Features inside existing typed code, following established patterns | 0-2 years | Basic annotations, interfaces and type aliases, union types, fixing compiler errors without reaching for any |
| Mid-level | Typed features end to end, including API calls and forms | 2-5 years | Generics, narrowing, discriminated unions, runtime validation, typed React components and Node.js handlers |
| Senior | Type architecture, shared packages, compiler settings and migration strategy | 5+ years | Conditional and mapped types, end-to-end contracts, monorepo builds, type-check performance, teaching type design |
Tips for writing a TypeScript developer job description that attracts senior talent
- Explain why TypeScript is the headline. If the role is really a React or Node.js job, title it that way. Use "TypeScript developer" when type architecture, contracts or a migration is the core of the work.
- Publish your compiler settings. Saying "strict is on, noUncheckedIndexedAccess is next" tells a senior candidate exactly how mature the codebase is.
- Be honest about the any count. A codebase with thousands of
any types is a good job for the right person. Say so, and say you will give them time to fix it. - Name how types cross boundaries. tRPC, OpenAPI codegen and GraphQL Codegen lead to very different daily work. Mention which one you use or are considering.
- Avoid type puzzle interviews. Senior developers value readable types over clever ones. Say your interview focuses on typing a real API or domain model, not on type-level challenges.
- Mention build tooling. Whether you compile with tsc, use esbuild or SWC for transpiling and run type checks separately affects the work. Senior candidates will ask.
Skip the job post: hire a vetted senior TypeScript developer
Writing the job description is only the first step in a hiring cycle that can run for months. If you need senior TypeScript capacity sooner, Ryz Labs can match you with senior TypeScript developers from Latin America who work on your team, work in your monorepo and join your standups, within an hour of US time zones. Only the top 1% of the engineers we interview make it through our vetting, which covers type design, runtime validation, full-stack contracts and practical debugging.
Our staff augmentation model lets you add one developer or several without reworking your process. Ryz engineers work on your team and report to your leads. Talk to us to scope the team you need. If you are hiring on your own, our TypeScript interview questions cover what we test and what strong answers sound like.
FAQ
What is the difference between a TypeScript developer and a JavaScript developer?
Both write the same runtime code. A TypeScript developer is hired for type design: shared types, typed API contracts, compiler settings and safe migrations. A JavaScript developer is hired more for runtime depth, such as the event loop and Node.js performance. Many senior engineers do both, so title the role by its main problem.
Should I require advanced type-level programming skills?
Require solid generics, narrowing and discriminated unions. Deep type-level programming matters mainly for library or SDK authors. For product teams, a developer who keeps types simple and readable is usually more valuable than one who writes complex conditional types.
Is it worth hiring someone just to migrate to strict TypeScript?
Often, yes, as long as the role includes feature work too. A focused senior developer can turn on strict settings package by package while shipping, which is far less disruptive than a stop-the-world migration. Frame it as a project inside a broader role.
Questions we didn't answer? Email info@ryzlabs.com.