Senior TypeScript developer for end-to-end type safety
Based in Wroclaw, Poland · EU timezone · Available for new projects
TypeScript is my default for every project. Not just adding types to JavaScript — I design systems where the compiler catches bugs before they reach production. From monorepo library authoring to full-stack type safety with tRPC and Zod, I make TypeScript work as a productivity tool, not a tax.
Full-stack type safety
End-to-end typed systems with tRPC, Zod, and Prisma. A change in the database schema surfaces as a type error in the frontend — no runtime surprises. Shared types between client and server with zero code generation lag.
Monorepo setup and library authoring
Turborepo or Nx workspaces with shared packages, proper tsconfig inheritance, and build pipelines. Internal libraries with clean exports, versioning, and changelogs. Code shared across apps without copy-paste.
JavaScript to TypeScript migration
Incremental migration of existing JS codebases to strict TypeScript. I start with the foundation (config, shared types, API contracts) and work outward. No big-bang — your team keeps shipping features while the migration progresses.
API contract design
Typed API contracts with Zod schemas serving as both runtime validation and static types. OpenAPI spec generation, client SDK typing, and shared validation between frontend forms and backend endpoints.
Complex domain modeling
Discriminated unions for state machines, branded types for IDs, template literal types for string patterns. I use the type system to encode business rules so invalid states are literally unrepresentable in code.
Advanced type system
Generics, conditional types, mapped types, template literals, and utility types. I write types that are complex enough to be useful and simple enough to be maintainable. The type system is a tool, not a puzzle.
Runtime validation with Zod
Zod schemas that serve as both runtime validators and TypeScript types. Shared between frontend forms, API endpoints, and configuration parsing. One source of truth for what data looks like.
Monorepo tooling
Turborepo and Nx for build orchestration, proper tsconfig paths and project references, package.json exports fields, and conditional builds. I make monorepos that are fast to build and easy to navigate.
Strict compiler configuration
Strict mode from day one: noUncheckedIndexedAccess, exactOptionalPropertyTypes, strict null checks. I configure the compiler to catch real bugs, not just silence warnings.
Migration strategy
I migrate JS to TS incrementally without blocking feature work. Start with strict config, add types to shared modules first, then expand outward. Each PR makes the codebase more typed without breaking anything.
Performance-aware typing
Types that don't slow down the IDE. I avoid deep recursive types, excessive inference chains, and overloaded declarations that tank TypeScript Language Server performance on large codebases.
Type architecture
I define the shared types, API contracts, and validation schemas before building features. We align on the type boundaries between systems so everything fits together from the start.
Build with strict mode
Every file is strict from the beginning. I use the type system to prevent bugs at compile time rather than catching them in production. Code reviews focus on correctness, not just style.
Ship with confidence
Full type coverage means refactoring is safe, onboarding is fast, and your team can ship features without fear of breaking unrelated parts of the system.
Yes. The overhead is minimal with modern tooling, and the benefits start immediately — better autocomplete, catch bugs before running the code, and self-documenting function signatures. Even for a weekend project, I'd use TypeScript.
Yes. I do incremental migrations — you don't need to stop shipping features. I start with the tsconfig and shared types, then convert files progressively. Each PR adds type safety without disrupting the team's workflow.
TypeScript adds a type system on top of JavaScript. It catches errors at compile time, provides better IDE support, and makes refactoring safer. The code compiles to plain JavaScript — no runtime cost. A TypeScript developer writes JavaScript, but with guardrails that prevent entire categories of bugs.
Never any — it defeats the purpose of TypeScript. I use unknown at system boundaries (external API responses, user input) and narrow it with Zod validation. Inside the application, everything is strictly typed.
tRPC for full-stack Next.js apps (zero-cost end-to-end types), or shared Zod schemas in a monorepo package consumed by both sides. The goal is one source of truth — change the API, the frontend shows a type error immediately.
I work on a daily or monthly rate depending on the engagement. Book a free 30-minute call and I'll give you an honest estimate based on your project scope.
Ready to hire a senior TypeScript developer?
Book a free 30-minute technical call. I'll review your requirements and tell you honestly if I'm the right fit.