AI Builder

Mekari is Indonesia's no. 1 Software-as-a-Service (SaaS) company. With our ecosystem of software solutions—including Mekari Jurnal, Mekari Talenta, Mekari Qontak, and Mekari Flex, we aim to facilitate entrepreneurs and leaders as they accelerate the digital transformation of their businesses.

In our 10+ years of journey we have reached over 3 Million platform users, and we're not planning to stop any time soon. We need more people like you: builders and owners with calculated ambition who are ready to #ElevateThroughImpact and raise Indonesia's software standard.

Role summary

We are building the shared inference platform that every product in the company reaches AI through: one governed path to external model providers and to the models we host ourselves, with smart routing on top of it. Through those products it reaches thousands of businesses and millions of users.

The scope is deliberately hybrid. The platform side governs predictable behaviour: APIs, authentication, tenant policy, quotas, metering, routing execution, capacity, reliability, security, observability, and deployment. The AI side governs variable behaviour: task understanding, model selection, prompts, retrieval, tool use, small specialised models, output quality, guardrails, evaluation, and feedback. Routing is where the two meet. A request has to be allowed under its tenant policy, and the option chosen has to meet the task's quality, latency, and cost requirements. A response that succeeds technically but fails the user's task does not count.

This is a full stack role with an LLM engineering core. You will own the API and the backend services behind it, the web control surfaces people operate the platform through, the models and drivers it serves, and how all of it behaves in production under real load.

How this role ships end to end

• Platform shipping. Reliable, secure, observable inference APIs, routing policies, provider and self-hosted model connections, tenant controls, metering, and the control surfaces teams use to see and manage them.

• Intelligence supply. Task-specific small models, model configurations, and agent drivers that teams can invoke through the platform. An agent driver combines a model with instructions, retrieval, tools, and validation behind a versioned interface.

• Evaluation and feedback. Task datasets, benchmarks, production monitoring, and release gates, using observed failures and economics to improve models, drivers, and routing decisions.

Core responsibilities

• Stay close to the tasks, acceptance criteria, quality risks, traffic patterns, customer feedback, and incidents of the products that use the platform
• Own the request path: API contracts, authentication (OAuth2), role-based access control, tenant isolation, policy, routing execution, fallback, streaming, and metering
• Design and build secure REST APIs and streaming endpoints, and backend services that stay correct under concurrency, partial failure, and traffic spikes
• Build the web control surfaces that make a complex system legible, so an operator can see state and act on it without reading source code
• Integrate and operate external model providers and self-hosted inference endpoints, and maintain a versioned catalogue of approved models, drivers, capabilities, limits, and prices
• Measure serving performance under realistic prompt lengths, output lengths, concurrency, and traffic mixes, then plan capacity and optimise configuration and cost
• Build small task-specific models, prompts, retrieval flows, and agent drivers for well-defined product or customer tasks, then expose them through the platform
• Define task-level quality and unacceptable behaviour with product teams and domain experts, and assemble representative evaluation and holdout datasets
• Compare candidate models and drivers against the current baseline on task success, safety, latency, and cost before shifting traffic
• Implement policy-aware routing, confidence or uncertainty escalation, safe fallbacks, and customer-specific controls where the evidence justifies them
• Use shadow traffic, staged releases, regression evaluations, monitoring, and rollback to introduce new serving or intelligence behaviour safely
• Track production failures and feedback, then improve the whole system: data, prompts, models, tools, policies, capacity, and operational controls
• Model data carefully in PostgreSQL, and measure usage and cost accurately enough to report and bill from
• Protect tenant data throughout the request path, respecting privacy, residency, and model-use boundaries
• Maintain dashboards, alerts, runbooks, incident response, and clear ownership for the platform and the capabilities it serves
• Work with product teams, AI engineers, domain experts, infrastructure, and security to make capabilities reusable across products
• Keep team knowledge written down: technical requirements, API contracts, design notes explaining model choice and routing policy, deployment notes, and post-mortems
• Mentor other engineers and raise the bar on design and code quality through review

Typical deliverables

• Production API and control surfaces for model access, policies, tenant boundaries, quotas, metering, and usage visibility

• Versioned provider and self-hosted model integrations, routing rules, fallbacks, and capacity configurations

• Task-specific small model endpoints and agent drivers with declared inputs, outputs, limits, owner, and release version

• Representative evaluation datasets, baseline comparisons, regression checks, and release thresholds for each capability

• Serving benchmarks covering latency, throughput, concurrency, capacity, failure behaviour, and cost per completed task

• Observability dashboards, quality monitoring, alerts, runbooks, staged rollout plans, and rollback paths

• Design notes explaining model choice, routing policy, tenant boundaries, trade-offs, and measurable improvement

Success measures

• Adoption grows across products and customers while user satisfaction stays high
• Product teams and customers can reliably invoke approved models and drivers through one governed path
• The rate of successfully completed tasks improves while quality, safety, and tenant-policy thresholds hold
• Cost per successfully completed task falls, measured by use case and traffic segment rather than raw token price alone
• Latency and availability meet agreed service objectives under realistic concurrency and prompt or output sizes
• Smaller models and agent drivers earn production traffic through measured quality and economic advantage over the baseline
• Model and routing changes are evaluated, versioned, released progressively, monitored, and reversible
• Defects, regressions, unsafe behaviour, capacity issues, and cost anomalies are caught early
• Reusable capabilities cut the effort another product team needs to adopt the platform

Requirements

We are hiring a full stack engineer with real LLM engineering experience. Strength across backend and inference matters most; working competence in frontend is expected, since the control surfaces are part of the platform.

Engineering

• 4+ years of software engineering experience in a team setting, building and running production web applications
• Strong JavaScript and TypeScript, with production Node.js experience
• Production experience with at least one modern frontend framework. Vue is preferred; React or Next.js also works, and we will expect you to become effective in Vue regardless of which you arrive with.
• Working knowledge of Go language
• PostgreSQL in production: schema design, indexing, transactions, and diagnosing a slow query rather than guessing at it
• REST API design, plus practical experience with streaming responses and long-lived connections
• Testing as part of the change rather than a later cleanup (TDD or close to it), and comfort with code review as a two-way conversation
• Good understanding of microservices design patterns and where they cost more than they return

Production and infrastructure

• Demonstrated ownership of scalability and reliability in high-traffic systems, including API gateways, load balancing, and operating against availability and error-rate targets
• Security fundamentals in day-to-day work: OAuth2 and role-based access control, credential handling, tenant isolation, input validation, and least privilege
• Docker, and container orchestration with Kubernetes and Helm
• CI/CD pipelines and Git-based workflows, including release and rollback
• A public cloud in production. Experience with Alibaba Cloud, AWS, GCP, or Azure.

AI and inference experience

• You have shipped LLM-backed features to real users, not only prototypes
• Familiarity with multiple model providers and their APIs (OpenAI, Anthropic, and others), including aggregators, and an understanding of where their contracts differ in practice rather than in documentation
• Practical grasp of streaming responses, tool and function calling, embeddings and retrieval (RAG with a vector database), multimodal input, and provider batch and file APIs
• Experience deploying and operating self-hosted models in production (LLMs, embedding, speech-to-text, text-to-speech, or multimodal) with an inference server such as vLLM, TGI, or Triton
• Ability to diagnose serving behaviour: queueing, time to first token, generation speed, throughput, context limits, capacity, availability, and unit cost
• Experience building agent workflows that automate multi-step processes, and knowing where they need guardrails
• Experience building or tuning small task-specific models, or getting a task done with the right mix of prompts, context, retrieval, tools, and validation
• Evaluation as a habit: representative datasets, baseline comparisons, regression suites, error analysis, and human review where judgement is needed
• Awareness of cost and latency as product constraints, not afterthoughts, measured per completed task rather than per token alone
• Working proficiency with AI-assisted development tools such as Claude Code or Codex, and the discipline to review AI-generated code rather than ship it unread

Collaboration and ways of working

• Experience collaborating directly with product teams and AI engineers on technical development of features and services
• Familiarity with Scrum and Kanban
• Strong written and verbal communication, with a habit of sharing context with teammates and stakeholders
• Ability to build and deploy solutions independently, from problem framing to production

Nice to have

• Experience deploying models across multiple GPUs or multiple nodes, or fine-tuning models for a specific use case

• Experience with microfrontend architectures (e.g. Module Federation, single-spa)

• Experience with Ruby frameworks (e.g. Rails, Sinatra)

• Experience building internal developer platforms or APIs consumed by other engineering teams