About Me — Sirui Liu | Backend, Systems & Applied AI

English | 中文

I am Sirui Liu, a Computer Engineering co-op student at the University of Waterloo, building backend services, developer tools and infrastructure that carry an idea through to deployment and day-to-day use. On GitHub, I am WorldVanquisher.

My work spans Go and SQLite services, React interfaces, Python and TypeScript tooling, Linux operations, AWS and Azure, and hardware–software integration. I am especially interested in backend, platform, DevOps and applied AI engineering roles, and am open to 4- or 8-month co-op opportunities.

Email · GitHub · LinkedIn · Engineering articles

What I bring to an engineering team

End-to-end delivery: a learning-data service with 40+ HTTP endpoints, a React workbench, persistent storage, search, automated checks and an AWS-hosted demo environment.
Data integrity and recovery: versioned records, append-only review history, idempotent writes, fenced index publication and checksum-verified releases.
Applied AI with measurable behavior: embedding services, retrieval evaluation, inspectable hybrid ranking and human-confirmed Concept suggestions.
Operational experience: production CRM support, cloud reporting automation, and a self-hosted Linux environment running services I maintain.
Collaborative development: 10 merged contributions to Novel Ontology Pi, alongside my own projects and a team IoT prototype.

Experience

AsiaInfo Technologies — IT Operations Intern

September–December 2025 · China · China Telecom Hebei CRM Platform

I worked on the reliability and maintainability of a production CRM environment, connecting operational troubleshooting with database cleanup and deployment automation.

Built a Gitea Actions pipeline to run linting, unit tests, and Docker builds on pull requests, blocking merges when checks failed.
Optimized Dockerfiles to reduce CRM backend image size and standardized development and test configurations with Docker Compose.
Developed Python scripts to clean legacy and invalid CRM database records, addressing recurring backend errors.
Automated server log cleanup with Bash scripts to prevent disk-space-related service interruptions.
Resolved 500+ production CRM issues by investigating database inconsistencies, service-order failures, and business-workflow errors.

Pallet Connect — WE Accelerate Student Consulting

2025 · University of Waterloo team consulting project

I contributed to an ERP reporting and natural-language data-access solution, connecting business reporting needs with Azure-hosted services and deployment automation.

Automated daily and weekly ERP reporting by developing and deploying a REST API on Azure App Service, replacing manual report preparation.
Integrated Azure OpenAI with ERP data to answer natural-language requests through SQL queries restricted to read-only database access.
Built GitHub Actions deployment pipelines with Azure App Service slots and provisioned infrastructure through ARM templates and Azure CLI for reproducible deployments.

French Learning Hub — from learning questions to searchable knowledge

July 2026–present · Project owner · Go, SQLite, React, TypeScript, Docker, Qdrant, AWS

Repository · Architecture · Development history · Case studies

I built French Learning Hub to turn questions scattered across French-learning conversations into a durable knowledge system. A learner can capture a question, review its interpretation, extract knowledge units, organize Concepts and search back to the original evidence. I own the product direction, architecture decisions, task definitions, review and deployment workflow; implementation uses Claude Code and Codex alongside that engineering process.

The core design keeps the learner’s words, model interpretations and human decisions separate. Versioned analyses and append-only feedback preserve history; current membership and derived support make it possible to correct a Concept without rewriting its evidence. The React workbench connects these backend rules to a practical review workflow.

Representative results:

Area	Delivered result
Backend	Layered Go service with 40+ HTTP endpoints, SQLite transactions, versioned migrations and idempotent capture ingestion
Search	Keyword, semantic and explicit hybrid modes; persistent embedding cache; lease-protected Qdrant publication
Workflow performance	Initial review payload reduced from about 821 KB to 27 KB on a synthetic fixture with 1,543 reviewable units, using keyset pagination
Retrieval evaluation	Four baselines and Recall/MRR reports; exploratory synthetic E5 Recall@5 44/48, compared with BM25 32/48
Verification	126 integrated hybrid-search checks with real Qdrant and synthetic embeddings; CI also covers backend, frontend and public-demo browser workflows
Infrastructure	Docker personal-use release, Linux amd64/arm64 demo packages, Terraform EC2 environment and SSM administration

The full milestone record below covers the service, retrieval experiments, releases, cloud tooling and daily workflow. Measurements retain their fixture scope; they describe engineering behavior rather than external-user adoption.

Engineering milestones

Learning records, concepts and full-stack architecture

Built a Go service with 40+ HTTP endpoints and SQLite storage to capture learning questions, review AI analyses, and organize searchable knowledge.
Preserved analysis and correction history with versioned records and append-only feedback, using SQLite transactions and idempotent imports to avoid partial writes and duplicate captures.
Separated immutable learning evidence from derived concept state, computing support at read time so re-extraction cannot silently rewrite earlier records.
Built a concept-review workflow with 7 relationship decisions, append-only history, and idempotent recovery so corrections remain traceable after interrupted responses.
Built a React and TypeScript workbench for importing records, correcting analyses, and reviewing concepts, with links back to the original question.
Built a read-only knowledge library combining keyword and optional semantic search, with each concept linked to its source record and interpretation.

Retrieval, GPU inference and evaluation

Cached embeddings in SQLite by content hash, model, and dimensions so Qdrant indexes can reuse vectors across rebuilds and service restarts.
Deployed a multilingual embedding service on an RTX 4070 laptop and connected it to a Linux NAS through Tailscale with bounded requests and explicit deployment identities.
Compared 4 retrieval baselines on an exploratory synthetic dataset, recording Recall@5 of 44/48 for multilingual E5 versus 32/48 for BM25.
Diagnosed float16 embedding drift across 6 GPU configurations and selected singleton inference after repeated vectors and top-5 rankings remained unchanged in the tested matrix.
Exported versioned concept annotations with dataset-quality reports so retrieval baselines can be compared against a fixed evaluation population.
Made AI providers optional and interchangeable, rejecting invalid configurations at startup instead of silently changing analyzers or extractors.

Release, concurrency and CI

Packaged the API and frontend in a Docker image with health checks, readiness checks, persistent storage, and documented backup and upgrade procedures.
Protected concurrent indexing with SQLite leases and fenced writes, publishing per-run vector collections through an atomic pointer update.
Added pinned-Qdrant integration checks to GitHub Actions to validate index recovery, cache reuse, and concurrent publication, failing CI when tests were skipped.
Prevented duplicate and conflicting imports with strict JSON validation, canonical SHA-256 fingerprints, and atomic SQLite transactions.
Structured a Go service with 40+ HTTP endpoints into domain, application, storage, and transport layers, with SQLite persistence and versioned migrations.
Built a retrieval evaluation framework reporting Recall@1, Recall@3, Recall@5, and MRR against human-reviewed concept annotations.
Built GitHub Actions checks for Go tests, static analysis, and frontend builds to validate backend and React changes before release.

AWS backup, inference and recovery tooling

Built Python backup tooling and a CloudFormation template for synthetic SQLite snapshots in private S3 storage, with encryption, TLS-only access, and lifecycle expiration.
Created WAL-consistent SQLite snapshots with the online backup API and checked isolated restores using hashes, integrity checks, foreign keys, and data fingerprints.
Added StackId, ownership-tag, and deletion-receipt checks to reject cloud cleanup requests when resource identity or cleanup evidence was inconsistent.
Enforced request and byte limits for S3 and Bedrock with a persistent ledger that reserves usage before calls and counts failed attempts.
Built an HTTP adapter connecting Bedrock Titan embeddings to the Go provider interface, validating model identity, request bounds, and vector dimensions.
Validated 6 live Bedrock Titan embedding requests in Canada Central, checking 512-dimensional vectors for finite values, nonzero magnitude, and normalization.
Tested AWS backup and inference failure paths with 82 automated tests and 56 fault-injection observations using local fakes and SDK stubs.
Bound resumable embedding runs to input hashes and model settings so incompatible results are not reused and earlier usage accounting is retained.

Hybrid search, diagnostics and experiment tooling

Combined SQLite keyword and Qdrant semantic results through reciprocal rank fusion, with bounded candidates, deterministic tie-breaking, and checks against current records.
Built a hybrid-search API and React interface exposing component ranks and fused scores so users can inspect why records were retrieved.
Validated hybrid-search ranking and recovery with 126 integration checks using real Qdrant, synthetic embeddings, and an independent ranking oracle.
Built a React and TypeScript dashboard displaying dataset-quality reports and retrieval metrics, with separate loading, error, and unavailable-data states.
Built PowerShell and Python lifecycle tools for an embedding service, with readiness checks, process-identity validation, graceful shutdown, and log retention.
Added fixture-hash validation, timeout failures, and output-path protections to a retrieval experiment runner, with parity checks against production data conversions.

Read-only demo, release integrity and cloud deployment

Built a read-only demo with immutable SQLite storage and a server-side route allowlist that rejects writes and restricts access to curated synthetic learning records.
Packaged precomputed E5 document and preset-query vectors so semantic and hybrid demo searches run without a live encoder or model API.
Closed a static-file symlink escape by confining file opens to the web root and rejecting linked paths outside the served directory.
Added versioned domain fingerprints and artifact validation to reject inconsistent demo data, model metadata, and extraction-selection state before startup.
Built Linux amd64 and arm64 release packages bundling the Go server, React frontend, model artifacts, source metadata, and SHA-256 validation.
Added GitHub Actions acceptance checks for demo HTTP routes and browser workflows, including controlled failure probes, process cleanup, and bounded diagnostic artifacts.
Added Inspector actions to reassign, invalidate, and restore reviewed units, rechecking current state before writes and reconciling unknown outcomes through read-only checks.
Implemented English and Simplified Chinese interfaces with typed message catalogs, preserving drafts, pending operations, and stored learning content when switching languages.
Provisioned an AWS EC2 demo environment with Terraform, private S3 release storage, scoped IAM policies, and Session Manager access without inbound SSH.
Built an S3 release installer with checksum verification, atomic release switching, readiness and artifact-identity checks, and rollback when post-deployment validation fails.
Prepared guarded HTTPS rollout tooling with DNS preflight checks, nginx configuration validation, certificate-renewal checks, and opt-in Terraform ingress changes.

Daily learning workflow and bounded loading

Added direct record navigation, review-position recovery, and incremental concept rendering so learners can revisit earlier records without restarting the review workflow.
Added Unicode-aware, case-insensitive record search using parameterized SQLite substring queries, composing text matching with state filters and cursor pagination.
Replaced full review-queue loading with keyset pagination and stable unit locators, preserving review eligibility and resuming from the last inspected unit.
Reduced the initial review-queue payload from 821 KB to 27 KB through cursor pagination on a synthetic fixture containing 1,543 reviewable units.
Built a unified question-intake interface for typed questions and JSON captures, reusing idempotent ingestion while keeping analysis and human approval explicit.
Handled uncertain saves with receipt lookups and explicit replay of the same capture identity, avoiding duplicate records after lost responses.
Built an isolated synthetic-data harness with 1,000 records, 3,000 knowledge units, and 500 concepts to measure read paths and validate complete learning workflows.

Latest milestones — bilingual explanations and AI-assisted review

In October 2026 I extended the workflow with stored English and Chinese explanations, separate controls for interface and explanation language, and per-language human corrections. Older records remain readable without invented translations or rewritten history.

I also added advisory Concept suggestions for explicitly selected batches. A model proposes from a bounded existing catalog; each membership change still requires an individual confirmation. The follow-up work handles lost responses, same-key replays, canceled clients and historical confirmations after later corrections. Generation and confirmation have separate identities and transaction boundaries.

Evidence: bilingual explanation validation, Concept suggestion implementation, recovery and correctness review.

Deployment and operating model

The personal service runs in a trusted environment. A separate read-only demo uses curated synthetic records and precomputed vectors, so visitors cannot write learning data or trigger model calls. The project includes a recorded EC2 deployment through SSM, checksum-verified installation, release switching and rollback. Public HTTPS rollout tooling is prepared; the recorded deployment evidence establishes private SSM access, with public cutover still pending.

Evidence: AWS deployment record, HTTPS rollout tooling, public-demo CI.

Personal AI Workbench — portable context and reliable handoffs

October 2026–present · Project owner · Python, CLI, Markdown, TOML, GitHub Actions

Repository · v0.2.0 release

I built a Python CLI to solve a recurring development problem: project decisions and task state get scattered across notes and coding sessions. PAI assembles task-relevant context within a character budget and creates structured handoffs that preserve human constraints and separate implementation, validation, commit, merge and deployment status.

The engineering work extends beyond prompt assembly: concurrent writers cannot overwrite reports, discovery is bounded, launchers pin imports to the installed bundle, and release packaging excludes personal configuration and handoffs. A 10-job CI matrix covers Windows, macOS, Ubuntu and four Linux container userspaces, including extracted-bundle smoke checks.

Engineering milestones

Context and explicit human decisions

Built a dependency-free Python CLI that prepares task context from registered project documents and creates structured handoffs for subsequent AI coding sessions.
Implemented deterministic context selection that prioritizes human constraints, ranks task-relevant sections, and reports omissions within a configurable character budget.
Separated implementation, validation, commit, merge, and deployment states in Markdown handoffs, preserving unknown states and keeping unapproved proposals distinct from human decisions.

Concurrent writes and bounded file discovery

Prevented concurrent handoff writers from overwriting reports through atomic directory creation, collision-aware naming, and exclusive file creation.
Built bounded handoff discovery with metadata validation, deterministic ordering, file-size limits, and diagnostics for malformed or unavailable reports.
Added path-containment and file-identity checks to handoff discovery, rejecting symlinks, Windows reparse points, and files changed between inspection and opening.

Cross-platform launchers, releases and CI

Built Windows and POSIX launchers that locate Python and pin imports to the installed bundle, preventing accidental loading of packages from the working directory.
Packaged matching ZIP and tar.gz distributions with allowlisted contents, SHA-256 checksums, and manifests, excluding local configurations and private handoffs from release bundles.
Built a 10-job GitHub Actions matrix validating tests, reproducible release builds, and bundle smoke checks across Windows, macOS, Ubuntu, and 4 Linux container userspaces.

Diagnostics, portable text and configuration

Built a read-only diagnostic command checking Python compatibility, bundle checksums, configuration paths, and registered sources, with actionable reports for missing or modified files.
Normalized CRLF Markdown input and UTF-8 output while writing handoffs with consistent line endings to support text portability across Windows, macOS, and Linux.
Built a configuration initializer with preview-by-default behavior, explicit write opt-in, and exclusive creation to avoid overwriting existing per-device settings.

Novel Ontology Pi — collaborative developer tooling and evaluation

October 2026–present · Open-source collaborator · TypeScript, Node.js, JSONL, Ladybug, Cypher, SSE

Upstream repository · My merged pull requests

I contributed 10 merged pull requests to a collaborative system that turns novels into queryable characters, events, relationships and timelines. My contributions span workspace initialization, configuration diagnostics, portable data transfer, query commands, streaming inspection, model-client integration and evaluation tooling. I also collaborate on the Jev-based extraction workflow, where proposed ChangeSets are reviewed before they become canonical records.

Two representative contributions are the bounded OpenAI-compatible client and the golden-chapter evaluator. The client reports attempts, latency and usage while handling timeout and retry policy. The evaluator compares stored predictions with reference records through deterministic matching and reports precision, recall, F1, missed records and spurious records.

Engineering milestones

Collaboration and model integration

Contributed TypeScript CLI features to a collaborative novel-ontology project through 10 merged pull requests covering data transfer, diagnostics, model integration, and evaluation.
Implemented an OpenAI-compatible LLM client with bounded retries, per-attempt timeouts, and token/latency reporting; tested JSON-mode requests and failure paths against a local HTTP mock.

Evaluation and prediction adapters

Designed golden-chapter evaluation tooling reporting precision, recall, F1, and missed/spurious records through deterministic ID and normalized-key matching without model calls.
Built a bundle-to-predictions adapter using stored chapter evidence, reporting unattributed records and rejecting non-empty output directories to prevent stale evaluation data.

Portable data, queries and event streaming

Implemented validated JSONL bundle import/export with staged copies, no-overwrite behavior, and explicit exclusion of derived graph databases and secret-shaped files.
Implemented Cypher query, text-search, and timeline CLI commands over existing Ladybug retrieval APIs, with resource cleanup and explicit missing-database errors.
Added a read-only, loopback SSE watcher over processing-event logs, with replay cursors, reconnect handling, and tests for malformed logs and client cleanup.

CI, diagnostics and ontology collaboration

Added GitHub Actions CI for clean Node.js installation and automated tests, plus configuration checks that report credential status without printing key values.
Fixed bundle loading to surface malformed JSONL instead of silently treating corrupted data as empty.
Contributed to a Jev-based ontology-extraction workflow using typed decisions and reviewable ChangeSets to separate proposed updates from canonical records.

Selected reviews: portable bundle transfer — PR #5, LLM client — PR #8, evaluation — PR #18, prediction adapter — PR #22.

MayaBot — self-hosted media automation

October 2025–present · Personal backend service · Python, SQLite, Docker, FFmpeg, Telegram, TOS

Repository

I developed MayaBot as a modular Telegram service running on my Linux NAS. It integrates music search and delivery, history-based recommendations, user feedback and scheduled subscriptions, alongside an image-generation pipeline using object storage and image composition.

The media work includes concurrency and resource controls: four download workers, serialized uploads and an aggregate download budget. In the recorded constrained-container run, eight downloads reached about 310 MiB peak memory on a 2-core, 1-GiB container. Encoding and cover optimization reduced combined media size by approximately 34% in a three-song sample.

Engineering milestones

Music ingestion, recommendations and persistence

Integrated Music Updater into MayaBot to retrieve tracks by title or artist, convert downloads with FFmpeg, and deliver music through Telegram.
Added SoundCloud handlers to Music Updater to provide an alternative when YouTube searches returned inaccurate matches or unsuitable recordings.
Separated polling, command routing, and error handling from feature handlers and API adapters so new bot commands can be added without changing core logic.
Built rule-based music recommendations from download history, search keywords, and artist-preference weights, using weighted random sampling to vary repeated suggestions.
Added recommendation feedback that adjusts artist weights and scheduled an opt-in daily delivery of 3 tracks.
Persisted downloads, searches, preferences, and subscriptions in SQLite on a mounted volume to retain recommendation inputs across container restarts.

Measured media processing and regression checks

Expanded download concurrency from 1 to 4 workers and validated 8 downloads with approximately 310 MiB peak memory on a 2-core, 1-GiB container.
Reduced combined audio and cover-image size by approximately 34% across a 3-song sample through encoding and image optimization, while reusing Telegram file IDs for repeat requests.
Validated media release behavior with 14 regression checks and constrained transfers through an approximately 1 MiB/s aggregate download budget and serialized uploads.

Deployment and operational debugging

Containerized the bot with Docker Compose on a Linux NAS and configured runtime credentials through environment variables.
Integrated network and external-API error handling into the self-hosted bot service.
Diagnosed a stale SOCKS proxy environment variable that broke HTTP while ping still worked, and documented the fix in a technical incident write-up.

Image pipelines and Telegram interactions

Integrated an image-generation API with TOS object storage to accept user images and render predefined meme templates.
Built inline-button search results accepting keywords or direct links and delivering tracks with embedded metadata and cover art.
Deployed the bot on an Arch Linux NAS with Docker Compose, persistent SQLite volumes, environment-based configuration, and automatic container restart.
Connected image-generation APIs, TOS object storage, and Pillow composition in a Telegram workflow that turns user input into rendered images.

Linux NAS — operating the systems behind my projects

October 2025–present · Arch Linux, systemd, Docker Compose, Samba, Tailscale

I repurposed a laptop into infrastructure for MayaBot, Paperless-ngx, Jellyfin and my development services. Maintaining that environment means working through service startup, persistent volumes, permissions, cross-platform file sharing and network behavior across containers and hosts.

Repurposed a laptop as an Arch Linux NAS to host containerized services including MayaBot, Paperless-ngx, and Jellyfin.
Configured systemd service management and Tailscale remote access, troubleshooting DNS, IPv6, storage, and container-networking issues.
Configured Samba and Tailscale to support file transfers across Windows, macOS, and Linux clients.
Diagnosed a stale SOCKS proxy environment variable that broke HTTP while ping still worked, and documented the fix in a technical incident write-up.

Incident write-up: ping worked while HTTP failed

EngHack — connecting sensors to a usable device interface

March 2026 · Team prototype · Arduino, Python, FastAPI, Serial I/O, Gemini

I contributed to an environmental-monitoring prototype with temperature and light sensors, a servo and a 16×2 LCD. My software contribution connected the device and backend: bidirectional JSON over serial, aggregation of 30 sensor samples per request, and generated recommendations constrained to the display format.

Contributed to an Arduino monitoring prototype integrating temperature and light sensors, a servo, and a 16-by-2 LCD.
Implemented bidirectional JSON communication between Arduino and a Python processing service exposed through FastAPI.
Aggregated 30 sensor samples per FastAPI request and integrated Gemini recommendations formatted for a 16-by-2 LCD.
Constrained Gemini-generated JSON responses to the device display format, connecting sensor measurements with feedback on a 16-by-2 LCD.

Earlier engineering foundations

Ultrasonic Smart Cane — ECE198

Team repository

My first formal engineering project introduced sensor integration, STM32 programming in C and the practical relationship between hardware behavior and software decisions. It established the hardware–software foundation I later applied to backend and device-integration projects.

Embedded Linux learning agent — archived experiment

June–July 2026 · C, Go, Buildroot, QEMU, SQLite, Docker

An earlier emulated-device project explored the connection between an AArch64 Linux target and a service backend. It remains part of my development history; my current work has moved toward FLH, developer tooling and infrastructure.

Integrated a C learning agent with quiz, daemon, and HTTP modes on an AArch64 Linux target built with Buildroot and emulated in QEMU.
Configured SysV init startup, CSV settings, and runtime logging for an emulated embedded Linux target.
Developed SQLite-backed Go endpoints for device-status reporting, progress synchronization, and task retrieval from a learning agent.
Packaged the device backend with a multi-stage Docker build and added Telegram commands for remote status and progress monitoring.

This blog — engineering notes and portfolio

I built this site with Hexo, Markdown and GitHub Pages and use it to document system incidents, design decisions and project case studies. The articles connect implementation details to the problems they solve and provide source links for further review.

Education and technical foundation

University of Waterloo · BASc, Computer Engineering, Co-operative Program · Expected April 2029

Academic average: 82.94%, based on my October 2026 transcript record.
University of Waterloo President’s Scholarship, 2025.
Completed foundations include programming, algorithms and data structures, digital circuits, computer organization, linear and electronic circuits, numerical methods, linear algebra and engineering mathematics.
Fall 2026 studies include systems programming and concurrency, embedded microprocessor systems, signals and systems, probability and statistics, discrete logic, and instrumentation/prototyping.
Engineering practice includes project design, technical communication and professional ethics; completed WHMIS training milestone in October 2024 and Work Terms 1 and 2.

Focus	Tools I have used
Backend and data	Go, Python, TypeScript/JavaScript, SQL, SQLite, Oracle SQL, FastAPI, REST APIs
Interfaces and tooling	React, Node.js CLI, Markdown, TOML, JSONL, SSE, Cypher/Ladybug
Infrastructure	Linux, Bash, systemd, Docker Compose, GitHub Actions, Gitea Actions, AWS, Azure, Terraform, CloudFormation, ARM templates, Tailscale
Retrieval and AI integration	BM25, embeddings, Qdrant, reciprocal rank fusion, Recall/MRR, precision/recall/F1, model API integration
Hardware and coursework	C, C++, STM32, Arduino, Serial I/O; MATLAB and VHDL through coursework

How I work

I enjoy the engineering between a working feature and a dependable system: deciding what owns the data, making failure states visible, choosing what to measure, and keeping deployment and recovery understandable. I use AI coding tools actively, and take responsibility for the requirements, design choices, review and results behind my projects.

If your team needs someone who can move between backend code, infrastructure, debugging and technical communication, I would welcome a conversation.

Contact me · LinkedIn

Updated October 25, 2026.