About

I am a software engineer experienced in developing microservices and monolith-based applications from my past experiences and projects. Currently interested in media streaming protocols and video processing, and I am always open to any opportunities in this domain.

Skills

Java

Node.js

Javascript

Spring Boot

Django

MySQL

PostgreSQL

MongoDB

RabbitMQ

Redis

Docker

Google Cloud Platform

Amazon Web Service

Kubernetes

Terraform

Featured Projects

Lox Interpreter

Interpreters

Recursive Descent

One program that reads Lox four different ways

Lox is the small language from Crafting Interpreters, and this is a complete interpreter for it written in Go. The first argument you pass picks how far along the pipeline to go — tokenize, parse, evaluate a single expression, or run a whole file — and main.go routes to each one. Below, it builds the interpreter, shows a two-line Lox program, and runs it to print the value stored in a variable.

A hand-written scanner that reports every bad character

The scanner reads the source one byte at a time — no regex, no generator library — and turns it into tokens: parentheses, operators, numbers, strings, and words. Words it recognizes from the keyword list become keywords (here `var` and `print`), everything else becomes a plain identifier. Each token also remembers its line number, so an error can point at the exact spot, and scanning keeps going after a mistake so every problem is reported in a single pass.

Parsing turns the flat token list back into a tree

The parser walks the tokens and builds a tree that records what binds tighter than what. The two examples below are the same shape of code: in `1 + 2 * 3` the multiplication is picked up first and lands inside the `+`, while the parentheses in `(1 + 2) * 2` flip that round. There is one small method per level of precedence, each calling the level below it, and unary operators just call the same method again for their operand. Every node can print itself, so the parse mode shows the tree as fully-parenthesized text — a quick check that the grouping is right before any math is done.

Variables, blocks, and shadowing

Variables live in an Environment: a map of names to values plus a link to the scope around it. A `{ }` block runs in a new child scope, so a variable declared inside it hides the outer one only for as long as the braces are open. That is why the same name prints `block` while the inner scope is alive and `global` again once it closes, with no cleanup code anywhere.

Redis-go

Redis

RESP

Replication

A server the real redis-cli can talk to

Clients don't send Redis commands as text — each message starts with a single byte that says what kind of value comes next: `+` for a status reply like OK, `$` for a string, `:` for a number, and `*` for a list of arguments. This reader switches on that first byte and reads the right shape accordingly, and writing does the mirror image. Because the format is spoken exactly, the actual `redis-cli` connects to this server and cannot tell the difference from the real thing.

Every client gets its own goroutine

The server accepts connections in a loop and immediately hands each one to a new goroutine, so a slow or idle client never holds up anybody else. Inside that goroutine it keeps reading lists of arguments off the wire and switches on the command name to run the matching handler — PING, ECHO, GET, SET, DEL and the replication commands. SET and DEL also forward the same command to any connected replicas, which is the hook the replication support is built on.

Keys that expire on their own

`SET key value PX 3000` stores a deadline with the value: the entry keeps the exact moment it should disappear, not a ticking countdown. Nothing runs in the background to clean up — an expired entry is simply treated as missing the next time somebody reads it, so a key nothing looks at again costs nothing. The terminal sets a key with a three-second life, reads it while it is alive, then reads it again after the deadline has passed.

A second server can follow the first one

Started with `--replicaof`, a second instance connects to the first one, runs the same handshake real Redis uses, receives a copy of the data, and then keeps applying every command the master forwards to it. So you can walk over to the replica and read a key that was only ever written on the master. The master's WAIT command asks its replicas to confirm they have caught up and only answers once they have, instead of just sleeping and hoping.

SQLite-go

SQL

B-Tree

Binary Formats

Reading the file the way SQLite writes it

A SQLite database is just a file cut into fixed-size pages, and page one begins with a 100-byte header: bytes 16 and 17 say how big the pages are. This pager is the only code that opens the file — it reads those two bytes once, and everything above it simply asks for a page by number. The terminal then asks the database to describe itself, and every line it prints was decoded out of that header and the schema table sitting on page one.

Walking the page tree to find every row

Table data is stored as a tree of pages. The pages at the top hold nothing but pointers to the pages below, and only the bottom ones hold real rows. The scan opens a page and looks at its type: a leaf page hands back the rows it contains, while an inner page follows each pointer down and keeps going until it reaches leaves. That single recursive walk is what every table read is built on, including a plain row count — counting 55,991 companies means visiting every leaf in the tree.

Rows are stored with no separators at all

Inside a page each row is packed as tightly as it can be: first the size of the row's header, then that header listing a type code per column, then the column values one after another with no commas, tabs, or padding between them. The reader has to lean on the type codes to know where each value ends — how many bytes a number takes, or how long a piece of text is. Here one row of the little sample database is read straight out of its stored bytes.

Enough SQL to answer a real query

The SQL side is its own small parser that understands SELECT, a list of columns, one table, and a single `=` condition, and turns that into a tiny statement object the storage code can walk. Names then have to be matched to stored columns, and there is one quirk worth knowing: an integer primary key is really the row's own number rather than something kept in the row, so `id` is printed from the row itself while `name` and the rest come out of the packed record.

Other Projects

public-moq-demo

An open-source project of an adaptive video streaming application utilizing QUIC

QUIC

WebTransport

TypeScript

MPEG-DASH

MEDIS

A webinar marketplace for Doctors and medical staff in Indonesia

Spring Boot

Java

Zoom API

Payment Gateway

Http-go

Simple implementation of HTTP Server made from scratch using Go

HTTP

TCP

Agroaid

An application for detecting diseases in plants

Node.js

MySQL

Work Experience

CIMB Niaga

July 2025 - Present

Software Engineer

Reduced document retrieval time from up to 5 seconds to under 0.7 seconds by building a document exploration platform with full-text search, fuzzy search, and an embedded PDF viewer using pdf.js.
Improved data consistency for internal RAG applications by designing and implementing an automated BullMQ pipeline to synchronize daily master data from external systems.
Enabled stakeholders to monitor AI adoption by developing an analytics dashboard to visualize internal AI application usage and trends.
Automated document ingestion for the internal RAG platform by integrating SharePoint and implementing scheduled synchronization jobs to maintain an up-to-date knowledge base.

AwanTunai

Aug 2024 - May 2025

Backend Engineer

Reduced memory consumption by 60% and CPU utilization by 50% by migrating multiple backend services from Java 8 to Java 21 and Spring Boot 2 to Spring Boot 3.
Reduced homepage p50 latency from 1.4 seconds to 0.7 seconds by optimizing MongoDB queries and introducing asynchronous request processing.
Automated invoice verification and flagged suspicious submissions by developing a machine-learning-assisted validation pipeline.
Simplified customer onboarding by developing a location-aware loan application workflow that enabled eligible customers to apply without sales assistance.

AwanTunai

Aug 2023 - Feb 2024

Backend Engineer Intern

Supported OJK regulatory compliance by developing a lender onboarding platform and implementing risk and compliance verification workflows using Spring Boot and MongoDB.
Automated lender document signing by integrating Privy digital signature services, reducing manual verification and document processing effort.
Delivered real-time loan submission and disbursement notifications by building an event-driven notification service using RabbitMQ and Firebase Cloud Messaging.

Faculty of Medicine

Feb 2023 - July 2023

Software Developer Intern

Built MEDIS, an end-to-end medical webinar platform using Spring Boot and React with Zoom Meeting API integration for automated webinar creation, scheduling, and management.
Automated webinar payment processing by integrating the Midtrans Payment Gateway with transaction status updates and purchase history management.
Implemented role-based authorization to support administrators, speakers, and participants across the webinar platform.

Bangkit Academy

Feb 2023 - July 2023

Cloud Computing Cohort

Built a plant disease detection application using Node.js and machine learning models for real-time diagnosis.
Deployed and managed containerized applications on Google Kubernetes Engine as part of the Google Cloud Engineer learning path.
Managed Google Cloud Platform resources across computing, storage, networking, and machine learning while completing over 900 hours of cloud computing coursework.

Education

University of Indonesia

Sep 2020 - July 2024

Bachelor's Degree in Computer Science

Relevant Coursework: Information System Development Project, Enterprise Applications & Architectures, Data Structures & Algorithms, Databases, Computer Networks, Operating Systems.