function optimize(query) { return query.explain(); }

SELECT * FROM users WHERE status = 'active';

git commit -m 'fix: resolve race condition in cache'

docker build -t app:latest .

kubectl apply -f deployment.yaml

import { useState, useEffect } from 'react';

#[derive(Debug, Serialize, Deserialize)]

async fn fetch_data() -> Result<Data, Error> { ... }

const [state, setState] = useState(null);

pub struct Server { port: u16, host: String }

def train_model(epochs=10, batch_size=32):

model.compile(optimizer='adam', loss='mse')

location / { proxy_pass http://backend; }

server { listen 80; server_name localhost; }

export const handler = async (event) => {}

console.log('Successfully connected to DB');

if err != nil { return err }

go routine() { channel <- data }

// TODO: Refactor this to be O(n)

function optimize(query) { return query.explain(); }

SELECT * FROM users WHERE status = 'active';

git commit -m 'fix: resolve race condition in cache'

docker build -t app:latest .

kubectl apply -f deployment.yaml

import { useState, useEffect } from 'react';

#[derive(Debug, Serialize, Deserialize)]

async fn fetch_data() -> Result<Data, Error> { ... }

const [state, setState] = useState(null);

pub struct Server { port: u16, host: String }

def train_model(epochs=10, batch_size=32):

model.compile(optimizer='adam', loss='mse')

location / { proxy_pass http://backend; }

server { listen 80; server_name localhost; }

export const handler = async (event) => {}

console.log('Successfully connected to DB');

if err != nil { return err }

go routine() { channel <- data }

// TODO: Refactor this to be O(n)

function optimize(query) { return query.explain(); }

SELECT * FROM users WHERE status = 'active';

git commit -m 'fix: resolve race condition in cache'

docker build -t app:latest .

kubectl apply -f deployment.yaml

import { useState, useEffect } from 'react';

#[derive(Debug, Serialize, Deserialize)]

async fn fetch_data() -> Result<Data, Error> { ... }

const [state, setState] = useState(null);

pub struct Server { port: u16, host: String }

def train_model(epochs=10, batch_size=32):

model.compile(optimizer='adam', loss='mse')

function optimize(query) { return query.explain(); }

SELECT * FROM users WHERE status = 'active';

git commit -m 'fix: resolve race condition in cache'

docker build -t app:latest .

kubectl apply -f deployment.yaml

import { useState, useEffect } from 'react';

#[derive(Debug, Serialize, Deserialize)]

async fn fetch_data() -> Result<Data, Error> { ... }

const [state, setState] = useState(null);

pub struct Server { port: u16, host: String }

def train_model(epochs=10, batch_size=32):

model.compile(optimizer='adam', loss='mse')

location / { proxy_pass http://backend; }

server { listen 80; server_name localhost; }

export const handler = async (event) => {}

console.log('Successfully connected to DB');

if err != nil { return err }

go routine() { channel <- data }

// TODO: Refactor this to be O(n)

function optimize(query) { return query.explain(); }

SELECT * FROM users WHERE status = 'active';

git commit -m 'fix: resolve race condition in cache'

docker build -t app:latest .

kubectl apply -f deployment.yaml

import { useState, useEffect } from 'react';

#[derive(Debug, Serialize, Deserialize)]

async fn fetch_data() -> Result<Data, Error> { ... }

const [state, setState] = useState(null);

pub struct Server { port: u16, host: String }

def train_model(epochs=10, batch_size=32):

model.compile(optimizer='adam', loss='mse')

location / { proxy_pass http://backend; }

server { listen 80; server_name localhost; }

export const handler = async (event) => {}

console.log('Successfully connected to DB');

if err != nil { return err }

go routine() { channel <- data }

// TODO: Refactor this to be O(n)

function optimize(query) { return query.explain(); }

SELECT * FROM users WHERE status = 'active';

git commit -m 'fix: resolve race condition in cache'

docker build -t app:latest .

kubectl apply -f deployment.yaml

import { useState, useEffect } from 'react';

#[derive(Debug, Serialize, Deserialize)]

async fn fetch_data() -> Result<Data, Error> { ... }

const [state, setState] = useState(null);

pub struct Server { port: u16, host: String }

def train_model(epochs=10, batch_size=32):

model.compile(optimizer='adam', loss='mse')

> hello_world.sh

Michael Gau

Software Engineer | Systems Builder

Building things that run fast and scale well. Passionate about distributed systems, developer tooling, and clean code.

j / k to scroll

: for command palette

~/about

I'm a software engineer who enjoys building reliable distributed systems and clean backend architectures. My journey started with writing small Bash scripts to automate repetitive tasks, and eventually grew into designing and operating production systems that handle large-scale workloads.

Lately, I’ve been playing around with OpenClaw and building small AI skills, mostly out of curiosity. I enjoy exploring what these systems can actually do in practice—how simple ideas turn into useful tools, and where they might go beyond software engineering into everyday problems that could genuinely make people’s lives a little easier.

Outside of engineering, I enjoy diving, hiking, and playing chess.

$ stack --list

Languages: Python, Golang, Java, TypeScript, JavaScript, SQL, Unix Shell

Storage: Distributed Storage (Object, Block, File, KV), Erasure Coding, NFS, FUSE, POSIX Semantics

Distributed: Consensus Protocols (Raft, Paxos), Replication & Consistency Models

Infra: Docker, Kubernetes, Terraform, Grafana, Prometheus, CI/CD, Git

Frameworks: Spring Boot, Node.js, Flask, MongoDB

Visa: Singapore Citizen, eligible for US H-1B1 and UK's HPI visas

~/experience

TikTok

Jul 2025 - Present

Software Engineer (SRE)

▹ Cloud Infrastructure (Object/File/Block/KV Storage)

Datature

May 2024 — Dec 2024

Software Engineer Intern

▹ MLOps Platform

Venti Technologies

Jan 2024 — Apr 2024

Software Engineer Intern

▹ Data Platform

~/projects

View All

mengyewgau's homelab

A self-hosted home server built around a NAS, running this portfolio and a suite of personal services via Docker. Handles its own reverse proxying, TLS termination, and container orchestration—giving full control over data and deployments without relying on third-party cloud infrastructure.

NAS Astro React +2

freeka.ph

Free Ka links hikers with expedition guides, offering booking services, navigation, official declaration processing, and standardized pricing for expeditions.

TypeScript Docker Expo +3

Saturn

A CLI cron job manager backed by Docker and SQLite. Saturn lets you register scheduled jobs that run as Docker containers, then manages their execution, logging, and lifecycle from a single persistent daemon.

Go Docker SQLite +2

OptiRound

Optimise ward scheduling for specialty nurses, minimising the number of trips and ranking the patients' priority based on factors including but not limited to urgency, condition, and illnesses.

Python Scheduling Algorithms Product Management

cd ./all-projects