Full Stack Developer

What this job actually is

We are building Xtra Helix — a multi-tenant university management and learning platform serving several universities at once. It replaces systems that have been running for more than a decade and are still in production every day: students enrolling in courses, lecturers building timetables, registrars issuing transcripts.

Here is what makes this different from ordinary CRUD work: we are changing the engine while the plane is still flying. The new platform and the old systems run side by side for the next 12–24 months. Data moves across one entity at a time. Users are not supposed to notice any of it.

If you have grown tired of jobs where you write an API and that's the end of the story — this is not one of those.

What you will actually work on

Backend (.NET) — the bulk of the role

• Build microservices in .NET 10 / C# 14 following Clean Architecture and CQRS (MediatR, FluentValidation)
• Design both REST APIs for clients and gRPC services for internal service-to-service communication
• Work with PostgreSQL under a one-database-per-tenant architecture — each university has its own database, which means one migration has to run correctly against every tenant
• Write event-driven integrations with Kafka (Schema Registry + Avro) — outbox/inbox patterns, idempotency
• Own observability that people actually rely on: OpenTelemetry, Serilog, Grafana Loki

Frontend — web and mobile

• Web: SvelteKit 2 + Svelte 5 (runes) + TypeScript + Tailwind 4, feature-slice architecture
• Mobile: Flutter (Dart 3.13) + Riverpod 3 + go_router + freezed + dio
• Both surfaces draw from the same design token and shared component layer — per-screen style overrides are treated as defects, not shortcuts
• Every screen must work across multiple themes (each university has its own brand) and in Thai and English

What everyone on the team does

• Write tests that mean something — unit, integration (Testcontainers against real Postgres, Kafka and Redis), and E2E (Playwright)
• Read legacy code to extract the business rules, never to copy the structure
• Review your teammates' code, and take review on your own

The stack we actually run (not the one we wish we ran)

• Backend: .NET 10, C# 14, ASP.NET Core Minimal API, MediatR, FluentValidation, EF Core
• Database: PostgreSQL (primary), Redis
• Messaging: Apache Kafka + Schema Registry (Avro), SignalR
• Service-to-service: gRPC / Protobuf
• Web: SvelteKit 2, Svelte 5, TypeScript, Tailwind CSS 4, Vite
• Mobile: Flutter, Dart 3.13, Riverpod 3, go_router, freezed
• Testing: xUnit v3, Testcontainers, Vitest, Playwright, axe-core
• CI/CD: GitHub Actions, Docker
• Observability: OpenTelemetry, Grafana, Loki, Serilog

What we need from you

• 3–5 years building software in .NET / C# on systems with real users
• Solid relational database skills — you can write efficient queries, read an execution plan, and explain where an index actually helps. PostgreSQL, SQL Server or MySQL are all fine; we can teach you Postgres.
• Experience with at least one frontend surface — Flutter or any web framework (React, Vue, Angular, Svelte). We are not looking for someone who is strong in all three stacks on day one.
• A working grasp of separating layers and dependencies — call it Clean Architecture, Hexagonal, or whatever you like, as long as you can explain why business logic should not know about the database
• Testing as a habit, not something you do when told
• Comfortable with Git in a team — branching, review, resolving conflicts
• Strong Thai communication. Our users, our domain vocabulary, and most of the legacy code we read are in Thai, and so is the team's day-to-day. Technical English reading is expected too.

Nice to have (you do not need all of these)

• Multi-tenant SaaS, especially the database-per-customer variety
• Event-driven architecture — Kafka, RabbitMQ, outbox pattern, eventual consistency
• Accessibility (WCAG), particularly screen reader testing against Thai content
• Experience with incremental legacy migration (strangler fig), as opposed to big-bang rewrites
• Cloud (Azure or AWS), Kubernetes, Infrastructure as Code
• Any background in education systems — enrollment, GPA calculation, timetabling

How we work (read this part carefully — it is the real filter)

• CI gates block. Accessibility (axe and Lighthouse), visual regression, security scanning, and warnings-as-errors. If it is red, it does not merge. There is no "we'll clean it up later" exemption.
• Passing on your machine is not evidence. CI is the verdict.
• Architecture decisions get written down as ADRs, somewhere other people can read them — not kept in one person's head.
• We do not copy the old system. Legacy code is evidence of what the business needs, never a specification for how to build it. If you find a rule nobody can justify, we want you to ask about it, not quietly reproduce it.
• There is no "my code." Anyone can change anything, through review.

This job may not suit you if

• You want a complete, settled specification before you start — plenty here is still open, and we decide it together
• You do not enjoy reading other people's code — this role involves a great deal of it
• You see tests and accessibility as extra work to be done afterwards

We would rather say this plainly in the posting than discover it in month three.