Fullstack Engineer (Frontend Depth)

Salary: Rp 8.000.000 – Rp 12.000.000 per month

Must have

• Min. 3 years of professional experience shipping fullstack features in production, or equivalent demonstrable skill.

• Can build and ship a feature across the whole stack: the screen, the API behind it, the data, and the tests. Our internal platform is a React (TypeScript) web app on Vite and a Express.js + Ruby on Rails API; fullstack experience in any comparable stack transfers in fast, Rails included.

• Extra strength on the frontend: a good eye, clean component work, and a build that matches the design (spacing and states included) are where you are most comfortable and want to go deepest.

• Writes tests for their own code as standard practice, unprompted.

• Uses AI and design-to-code tooling as leverage and verifies every result before shipping it.

• Comfortable working directly with client-facing deliverables under a Technical Lead’s guidance.

• Any exposure to a design system, Figma handoff, or a design-to-code workflow.

Nice to have

• Data-visualization or dashboard experience (charts, tables at scale, performance tuning).

• Consulting or enterprise-client delivery experience.

• A shipped fullstack project (production, personal, or open source) you can walk us through and defend.

• Deep backend architecture.

Deskripsi pekerjaan

Job Description

On our delivery squads, every engineer owns a module across the whole stack, its UI, its API, its data, and its tests, and carries it from prototype to working, tested software.

Depth is where you go deeper than the rest of the squad, while still owning your module end to end. Your depth is the frontend: the modules with hard web UI such as dashboards, data visualization, design-system implementation, and performance tuning. When a module has a difficult interface, it comes to you, and you build its API, its data, and its tests too, like every fullstack owner. You are the person the squad trusts with the hard UI problem, and you keep building the rest of the module yourself.

From day one, you own real modules on live client squads and on internal product, at a scope matched to your experience: routine-to-common frontend complexity you run independently, with a Technical Lead, a more senior fullstack engineer, or the Product Designer backing you on the hardest interface calls. As your frontend mastery deepens, the scope you own grows with it, on a clear path toward owning the seat’s hardest frontend cores outright.

What you will do

• Own a module across the whole stack: build its UI, the API behind it, its data, and its tests. You finish a whole feature.

• Take the modules where the interface is the hard part (dashboards, data visualization, design-system work, performance) and go deep there, while still delivering the rest of the module yourself.

• Build against the hi-fi prototype so a screen matches it exactly. A screen that looks different from the prototype is treated as a bug.

• Write the tests for what you build, from week one, as continuous regression.

• Turn a Definition of Done and a clickable prototype into working, traceable software, on real client engagements.

• Join story kickoffs and walk the acceptance criteria and edge cases before you write code.

• Use the design-to-code pipeline and AI as leverage, then verify. Producing plausible UI is cheap. Matching the prototype and the persona is the skill.

What you own now

• Modules built fullstack, end to end, at routine-to-common frontend complexity: UI, API, data, and tests, traced to a requirement and matching the prototype.

• Your module’s defects and its demo, including at least one dashboard or visualization view a stakeholder actually uses.

Who you will work with

• Reports to: Technical Lead. Hiring decision: CTO.

• You get a prototype and a Definition of Done from the product and tech layers, you get design fidelity checks from the Product Designer, and you hand the SDET a module that is testable in CI.