Senior Frontend Engineer

• Performance Review twice per year
• Work with battle-tested Frontend Engineers
• No unnecessary frameworks, pure mastery

About Us

• At our company, we're a team that is hardworking, logical, and fast to execute. We don't care what your degree is. If you're logical (no bullshit) and love building things that work, this is the place for you.
• We do not accept anything mediocre. Quality of work is everything. Even if you cannot achieve perfection at the beginning, we value the relentless effort to strive toward it.
• Our frontend is built with the way it was meant to be — simple, powerful, and production-ready. We especially welcome candidates who understand that good code doesn't need to be complicated.

You Should Apply If:

You loveeeeee building things — not (only) for money, but because you love creating something incredible

You learn new things every day — and get excited about diving deep into Frontend fundamentals

You hate over-engineered solutions to the bone — you've seen too many frameworks ruin simple problems

You know how to ask smart questions — not just "how?" but "why?" and "is this the right approach?"

You believe clean code beats smart code every single time

You love converting Figma to UI 100% accurately without needing a Designer to sit next to you

You understand comprehensive Analytics Tracking — not just firing GA4 Events but designing Event Architecture

What You'll Be Doing:

• Write (App Router + Server Actions + RSC) for real production systems
• Connect systems with TanStack Query + Zod for complete type-safe fetching
• Build UI that communicates well with users using Tailwind + Component Libraries
• Design and implement comprehensive Analytics Tracking — from Session/Page-level to E-commerce Events
• Work with UX/UI without having to guess or design yourself
• Integrate Turnstile, Animation with Framer Motion, Layout with Slot/Layout Pattern
• Optimize for fast, user-friendly, SEO-optimized web
• Deploy Frontend applications to production and optimize for performance, reliability, and maintainability

Must-Haves

Core Technical Skills

• Master (App Router / Server Component / SSR / ISR / Middleware) with deep understanding
• Write TypeScript deeply: union types, generics, conditional types, mapped types, utility types, type inference, return type annotations, strict mode configuration
• TypeScript Advanced Patterns: discriminated unions, branded types, template literal types, recursive types, module augmentation
• Expert in Tailwind: true utility-first, can separate variant/class systematically
• Fetch data with TanStack Query with caching, optimistic update, error boundary
• Use Zustand with selector + middleware + devtools
• Write Forms that actually validate with Zod sync/async + nested schema
• At least 5 years experience in JavaScript and understand how things work under the hood

Analytics & Tracking Expertise

• Design comprehensive Event Architecture — not just firing GA4 Events but designing Event/Parameter sets that serve the big picture
• UTM Persistence: read UTM from URL, store in Cookie/localStorage, send as User Property for every Event
• Comprehensive Tracking: page_view, click_cta, form_submit, scroll_percentage, video_progress, e-commerce events, js_error, Core Web Vitals
• Cross-session Campaign Tracking and Performance Monitoring

UX/UI/Production

• Convert Figma to UI 100% accurately — pixel-perfect implementation, not just "similar" or "approximately"
• Work closely with UX/UI Designer — understand design system, component variants, and responsive breakpoints
• Responsive Design, Accessibility, SEO
• Have deployed and encountered/fixed production problems for real
• Clean Code, Git, Testing
• English communication skills
• Happy and positive attitude — because building great software should be fun

Nice-to-Haves

• Experience with Frontend Component Frameworks: Ant Design, Chakra UI, MUI, ShadCN/UI, Radix UI
• Knowledge of Core Web Vitals: LCP, FID, CLS and optimization
• Experience with CI/CD (e.g., GitHub Actions, Vercel integration)
• Experience with Monorepo using Nx / Turborepo / Lerna
• Use ESLint / Prettier / CommitLint / Husky with discipline
• Knowledge of end-to-end testing tools like Playwright or Cypress
• Experience building multilingual and globally distributed web services

Key Principles & Our "Real Frontend" Philosophy

What Makes Us Different

• Don't test UI components directly in complex ways test business logic and important user interactions
• Test only what should be tested functions must work, not every component needs tests
• Don't over-abstract unnecessarily if your logic is separated well enough, you can maintain it
• Use real API calls for integration testing instead of mocking everything

Frontend Architecture We Love

• Separate components into 3 clear types:

o UI Components reusable, no business logic, pure presentation

o Feature Components business logic, data fetching, state management

o Layout Components page structure, navigation, common layouts

• Clear state management local state vs global state vs server state
• Consistent error handling error boundaries, fallback UI, retry mechanisms

Analytics Architecture We Want

• Event-driven Design every user interaction must have meaningful event
• Parameter Consistency use same naming convention throughout system
• Cross-session Persistence UTM and campaign data must persist across sessions
• Performance Monitoring track Core Web Vitals and custom performance metrics
• Error Tracking Integration js_error, api_error must go to analytics and error monitoring

Anti-patterns We Reject

What We Don't Want to See

• Write unnecessarily complex code / over-abstract
• Don't separate concern / logic / UI / data
• Use Hooks for everything until you can't understand
• Use Zod but don't actually validate / or just use isString
• Write TypeScript with any everywhere / don't use type safety
• Convert Figma inaccurately / just do "similar"
• Use Zustand with stores too big to control
• Write Tailwind until class name is 4 lines long (should use @apply, component class)
• Fire Analytics Events without system — no naming convention, no parameter consistency
• Don't store UTM persistence — just read from URL and throw away
• Don't track complete user journey — just track page view, not interactions

Tech Stack We Actually Use (No Bloat)

Core Frontend:

• (App Router, Server Components, Server Actions)
• React 18+ (Concurrent Features, Suspense)
• TypeScript (Strict mode, advanced types, type-safe APIs, branded types)
• Tailwind CSS (Utility-first, custom design system)

State Management & Data Fetching:

• TanStack Query (React Query v5) — server state management
• Zustand — client state management
• Zod — schema validation and type inference

Analytics & Tracking:

• Google Analytics 4 — comprehensive event tracking
• Google Tag Manager — tag management and custom events
• Custom Analytics SDK — type-safe event tracking with TypeScript, strongly-typed event parameters
• UTM Persistence Library — cross-session campaign tracking
• Performance Monitoring — Core Web Vitals tracking

UI & Animation:

• Framer Motion — animations and transitions
• Radix UI / Headless UI — accessible component primitives
• React Hook Form — form handling and validation

Development & Testing:

• ESLint + Prettier — code quality and formatting
• Jest + React Testing Library — unit and integration testing
• Playwright / Cypress — end-to-end testing
• Storybook — component development and documentation

Infrastructure & DevOps:

• Vercel / Netlify — deployment and hosting
• GitHub Actions — CI/CD pipelines
• Google Cloud Platform — backend services
• Sentry — error tracking and monitoring

Why You'll Love Working Here

Be Part of Something Real

• Build real things, used by real people, with real users — not just concepts
• Grow fast with biannual performance reviews and real ownership of your work
• Salary increases based on your growth — not years of experience or politics

Learn from World-Class People

• Write clean code with real code reviews, not just approval passes
• Learn from mentors who understand both theory and practice of Frontend

• No toxic people, no politics — just passionate developers who want to build great things

• Work Environment That Actually Works

• Flexible working hours — we measure output, not hours

• Office-based collaboration — work together in our office environment
• No micromanagement — we trust you to deliver results
• UX/UI ready for you — Dev just "Focus on Logic and Quality"
• Clear guidelines on what to do and what not to do
• Fast iteration cycles — see your code in production quickly

What We Value in People

• Can read documentation independently — no hand-holding needed
• Ask thoughtful questions — you think before you ask
• Take feedback without getting emotional — you understand code can always improve
• Love learning and growing — you want to become better every day
• Have fighting spirit — you don't give up when things get challenging
• Deliver more than expected — you surprise us in good ways