bootjp

Principal Engineer and Independent Researcher specializing in distributed systems. I translate business needs and operational constraints into system design, then carry the work through hands-on implementation and adoption. My work centers on two strengths.

1. Deep knowledge of distributed systems, distributed databases, and consensus algorithms

I work with consensus algorithms such as Raft end to end, from reading the papers to writing my own implementations in Go. I have designed and built a Raft-based Redis-compatible KVS and an Elasticsearch-compatible distributed search engine that combines Lucene with MicroRaft. I study architectures such as Spanner’s TrueTime, TiDB’s Timestamp Oracle, and the “Log is the Database” and compute-storage separation models behind Aurora and Aurora DSQL, organizing them as trade-offs between scalability and consistency, and I present on them regularly at DB Tech Showcase and cloud-native conferences. Because this knowledge is not tied to a single product, it translates directly into data store selection and design decisions in domains where inconsistency is unacceptable, such as payments and reservations.

2. Design, implementation, and operation of low-latency, low-cost large-scale content delivery infrastructure

I have consistently worked on delivery systems with demanding latency, throughput, and spike-tolerance requirements: advertising delivery, notification infrastructure for smartphone carriers serving tens of millions of users, and large-scale delivery infrastructure for a CX platform. I care about systems that stay cheap as well as fast. That focus produced a published proposal for a low-latency distributed KVS that cuts inter-node synchronization cost using a client-centric consistency model, a proposal for improving DNS cache hit rate and response speed (IPSJ Student Encouragement Award), and substantial delivery-infrastructure cost reduction through redefined SLOs and a framework for running preemptible instances safely. I look for room to reduce both latency and cost at each layer, from caching to name resolution to data placement. On my own time I also design and operate resize.gg, an image delivery CDN for VRChat.

I am currently Principal Engineer at hacomono, leading partial microservice decomposition and the design and implementation of a loosely coupled, schema-driven event bus for its multi-product strategy. I build robust and scalable system infrastructure by continuously cycling between theory (academic research and self-implementation) and practice (large-scale commercial development).

I also develop elastickv, an experimental distributed KVS and FUSE filesystem using etcd/raft and Pebble, and use it in my home lab. My current research focuses on LSM-tree block-cache optimization and leader-lease safety under process stalls and kernel hangs.

Skills

Distributed Systems / Distributed Databases / Consensus Algorithms
  • Raft / Multi-Raft, MicroRaft, etcd/raft, HashiCorp Raft (implementation & verification)
  • Distributed KVS / Search Infrastructure / FUSE File System Design & Implementation
  • NewSQL / Distributed Database Architectures (Spanner, TiDB, CockroachDB, Aurora / Aurora DSQL)
  • Lucene, Pebble (LSM-tree)
  • Compatible API Implementation: Key Elasticsearch APIs (professional work); Key Redis / DynamoDB / S3 APIs (personal development)
  • Event-Driven Architecture (Event Bus / Pub-Sub)
Databases / Caches / Data Processing
  • Redis (Streams / Pub/Sub), MySQL, MariaDB, MongoDB, Memcached
  • Bigtable, Spanner, DynamoDB
  • Operational Knowledge of Amazon MemoryDB
  • Apache Spark, Hadoop (HDFS / Hive / MapReduce), BigQuery
  • Log Aggregation / ETL / Data Migration; Detection of Database Queries Not Using Indexes
Large-Scale Delivery / Caching / DNS
  • Low-Latency Content Delivery: Design, Implementation & Operation (Throughput / Tail Latency / Traffic Spikes)
  • Distributed Cache / DNS Cache & Name Resolution Optimization
  • CDN & Edge Delivery: CloudFront, Akamai / DNS: Route 53
  • Personal Development: CoreDNS Plugins, GSLB Using Cloudflare DNS, Image Delivery CDN
  • Data Placement & Data Tiering for Personalized Delivery
Languages / Applications
  • Go, Java, Kotlin (server-side), PHP, Lua, C
  • JavaScript / TypeScript, SQL / Earlier Development Experience: Ruby, Perl
  • Runtimes & Frameworks: Node.js, Laravel, Netty, Jetty, Ruby on Rails
  • API Design: REST / gRPC, JWT
  • Schema-Driven Development: Protocol Buffers, Buf, protovalidate; Compatibility Checks / Shared Validation / SDKs
  • Real-time Network Systems / Metaverse Synchronization & Space Provision Backends
Cloud / Infrastructure
  • AWS: EC2, ECS, Lambda, API Gateway, SQS, ALB
  • Google Cloud: Compute Engine, Cloud Storage, Pub/Sub
  • Linux, Docker, Kubernetes, Migration to Containers
  • NGINX, Apache, Reverse Proxies
  • Multi-AZ Configuration / Fault Tolerance; Infrastructure Design for Vertical SaaS
  • Cost Optimization via SLO Redefinition and Spot / Preemptible Instances
Observability / Development Operations / Reliability
  • OpenTelemetry, Datadog, Sentry, Fluentd
  • Monitoring / Logging / Tracing Design; Operations Based on SLI/SLO & Error Budgets
  • GitHub Actions, Jenkins, CI/CD Pipeline Construction
  • Load Testing, Safe Data Flush on Termination Signals, Data Loss Detection During Failures
Research & Architecture Evaluation
  • Compute-Storage Separation / "Log is the Database" Architectures
  • Consistency Models (Linearizability / Client-Centric Consistency), Leader Lease Safety
  • Time & Global Ordering in Distributed Systems (TrueTime / HLC / Timestamp Oracle)
  • Cache Design & Algorithms (AdaptSize, etc.); LSM-tree Block Cache Optimization
Research / Technical Communication
  • Survey & Summary of Distributed Systems / Database Papers
  • Writing Technical Blogs & Conference Presentation Materials
  • Tech Community Management on VRChat (Distributed Systems Meetup)
  • Technical Documentation in Japanese & English

Creations

A collection of products created by bootjp.

Distributed Systems / Consensus Algorithms

  • create-raft-redis — An educational Redis-compatible KVS built with Go and HashiCorp Raft. Companion code for “Building a Raft-based Redis-compatible KVS in Go”; a separate implementation from elastickv
  • go-kvlib — Library for Raft-compatible KVS created for the above material
  • elastickv — An experimental distributed KVS and FUSE file system written in Go. Implements etcd/raft replication, Pebble persistence, routing across multiple Raft groups, and compatibility with key Redis, DynamoDB, and S3 APIs. Developed as open source and used in my home lab

Low-Latency, Low-Cost Delivery Infrastructure

  • resize.gg — Image delivery CDN for VRChat; designed and operated image delivery including resizing
  • dcache — Asynchronous distributed cache as a CoreDNS plugin. Shares resolved names across nodes over Redis Pub/Sub and keeps them in memory, improving latency in high-query environments (implementation and evaluation of the DNS cache improvement paper)
  • cloudflare-gslb — GSLB providing health checks and automatic failover for Cloudflare DNS records
  • simpleDNS — DNS forwarder / cache server

Tools & Libraries

Books (Technical Doujinshi)

  • Learning by Building: Raft-based Redis-compatible KVS in Go — TechBookFest 16. A hands-on book focused on building a strongly consistent KVS using the Raft consensus algorithm with Redis as a subject. Beyond implementation, it explores the fundamental necessity of Raft in distributed systems, drawing on real-world failure cases like AWS to explain the design philosophy of resilient systems. Build a distributed KVS from scratch to gain a practical understanding of distributed consensus.

VRChat Tools / Ended Services

Publications

Domestic Non-Peer-Reviewed Papers

  • Yoshiaki Ueda, Toshinobu Usui, Construction of a Low-Latency Distributed KVS for Personalized Content Delivery
  • Yoshiaki Ueda, Proposal for Improving DNS Cache Hit Rate and Response Speed for Distributed Systems
    • Proceedings of the 84th National Convention of IPSJ, 2022-03-05, Preprint, Student Encouragement Award

Technical Books (Doujinshi)

  • Learning by Building: Raft-based Redis-compatible KVS in Go
    • TechBookFest 16 (Technical Doujinshi / 79 pages, ver 1.2)
    • Goal
      • An introductory hands-on book that teaches distributed systems, consistency models, and Raft by implementing a Redis-compatible KVS.
    • Structure
      • The first half covers distributed systems fundamentals, Redis/Redis Cluster strengths and limitations, consistency models, and Raft core concepts (leader election, log replication, safety).
      • The second half connects theory to implementation through a full Redis-compatible KVS build.
    • Hands-on implementation (Go)
      • Uses hashicorp/raft, implementing the datastore, Snapshot, and StateMachine (Apply/Snapshot/Restore).
      • Implements RESP with redcon and supports GET/SET/DEL.
      • Handles follower-side requests via MOVED redirection to the leader, validated in a 3-node setup.
    • Production context
      • Links the design choices to real strong-consistency/high-availability use cases, including PayPay’s TiDB adoption.
    • TechBookFest Product Page / BOOTH

Presentations

Experience

Principal Engineer (Distributed Systems)

hacomono Inc.

Leading platform modernization for a vertical SaaS in the wellness industry, translating business needs and operational constraints into roadmap proposals, implementation, rollout, and the start of operations.

  • Planned and designed partial microservice decomposition on top of the existing platform to enable multi-product delivery.
  • Designed and implemented a loosely coupled, schema-driven event bus to connect the main product with new products. (Presentation)
    • Adopted for store and booking information integration in FitFits. (Case study)
    • Introduced reliable schema definitions using Protocol Buffers and common validation logic.
    • Improved developer productivity through CI-based compatibility checks (automatic detection of breaking changes) and internal SDK maintenance.
    • Established OpenTelemetry tracing and logging, SLI/SLO measurement, and Datadog dashboards/alerts for event delivery time, response latency, and downtime.
    • Partnered with new product development teams to define event contracts, rollout flows, and operational rules.
    • Led cross-team platform adoption support through onboarding, operational workflow design, and consultation handling.
  • Planned and designed scalable architecture updates to handle sudden traffic spikes in SaaS.
  • Operational improvements: Integrated automatic detection of queries that do not use indexes into CI to support continuous performance improvement.
  • Formulating and evangelizing distributed system design principles internally and externally.
    • Message Queue Reliability: preventing data loss during Worker crashes by advocating for Visibility Timeouts and atomic processing (e.g., Lua scripts/Redis Stream). (Article)
    • Cloud-Native DB Selection: Evaluating trade-offs between consistency and scaling based on ‘Log is the Database’ and compute-storage separation architectures. (Article)
    • Time & Consistency in Distributed Systems: Systematizing and explaining the impact of clock skew on consistency, with case studies on Spanner (TrueTime) and TiDB (Timestamp Oracle). (Article)
  • As Principal Engineer, supporting across the organization as a consultant and reviewer for distributed system designs.
    • Regularly joining architecture and recurring project meetings across multiple teams to understand system-wide context and challenges.
    • Running 1:1s with engineering leaders and VP/executive stakeholders to align priorities and drive cross-team problem solving.
    • Connecting consultation paths across teams to remove decision and execution bottlenecks.

Sep 2024 - Present

Representative / Distributed Systems Engineer

btj.systems LLC

Developed backends for distributed search and metaverse infrastructure.

  • Designed and implemented a distributed search engine using Lucene and MicroRaft in response to Elasticsearch licensing changes. Implemented sharding and compatibility with major Elasticsearch APIs, then delivered a production-capable system following prototyping and validation.
  • Addressed on-premises hardware constraints by detecting missing written data rather than relying only on successful write acknowledgements.
  • Developed backend services for network synchronization and space provision on a metaverse platform.

Jan 2023 - Apr 2025

Software Engineer (Distributed Systems / Delivery Infrastructure)

PLAID, Inc.

Responsible for developing the large-scale delivery and data processing infrastructure supporting the CX platform, where balancing low latency against low cost was the central theme.

  • Replacement and performance improvement of delivery systems handling massive traffic.
  • Implemented safe data flushing on termination signals to expand preemptible-instance use. Combined this with Bigtable, Spanner, and Compute Engine resource optimization to substantially reduce infrastructure costs; also redefined SLOs.
  • Acted as a technical advisor by researching academic papers on public clouds and providing feedback/insights to internal development teams.
  • Supported multiple teams across the organization as a technical consultation point for distributed data stores and event-driven architectures.
  • Organized design guidelines for operation-conscious loosely coupled architectures and shared them as documentation.

Oct 2021 - Jan 2023

Software Engineer (Search Infrastructure / Large-scale Delivery / Notification Infrastructure)

Supership Inc.

Responsible for development and operation of search infrastructure, large-scale data delivery, and notification management for smartphone carriers, designing and operating delivery infrastructure under simultaneous low-latency and high-throughput requirements.

  • Development of search engines and search-linked advertising systems, and construction/operation of large-scale aggregation infrastructure using Spark.
  • Designed and implemented an interval-tree-based algorithm to efficiently determine whether GPS coordinates fall within administrative-area polygons.
  • Backend development and stable operation of notification management systems for carriers with tens of millions of users.
  • Performance optimization and infrastructure design for massive data delivery in high-traffic environments.
  • Received an internal award for reducing log-infrastructure costs through Docker migration and spot-instance use. (Migration case study)
  • Contributed a startup connectivity check to Fluentd; PR #2184 was merged upstream.

Mar 2018 - Sep 2021

Software Engineer (Ad Delivery / Web Service Infrastructure)

Software Development Company (Confidential)

Developed advertising delivery, analytics, and web-service infrastructure.

  • Migrated a social-sharing button service from VMs to Docker; resolved container OOM kills by tuning Java caching and heap allocation.
  • Built an internal ad server using NGINX, Lua, and Redis, including SSP switching, detection of undisplayed ads, and log aggregation with Fluentd and HDFS.
  • Planned and developed an access-ranking service based on access-log analysis and market research; implemented defenses against forged referrers.
  • Automated aggregation and visualization of revenue, user counts, and page-view/unique-user KPIs.

Dec 2014 - Jan 2018

Representative / Developer

Best Network / BestNetWork Inc.

Started as a sole proprietorship in August 2005 and incorporated in May 2011.

  • Operated an ad-supported free hosting service, handling planning, design, implementation, server operations, and customer support.

Aug 2005 - Apr 2015

Organizer

Distributed Systems Meetup (Tech Community on VRChat)

Operating a study community specialized in distributed systems on VRChat.

  • Continuing reading circles and explanations of the latest distributed systems/database papers such as Aurora Serverless v2, MemoryDB, AdaptSize, etc.
  • Responsible for material composition and progression design to absorb skill level differences from beginners to practitioners.
  • Contributing to improving distributed system literacy across the industry through community management.

2018 - Present

Independent Researcher (Distributed Systems / Databases / Distributed KVS / Distributed Storage)

Independent Research

Researching performance improvements and fault-time safety in distributed storage and databases.

  • LSM-tree block-cache optimization: resubmitting after an international-conference submission.
  • Leader-lease safety: developing mechanisms that account for process stalls and kernel hangs; manuscript in preparation.
  • Clarified behaviors and trade-offs of strong consistency systems through implementation and verification of distributed storage using Raft.
  • Wrote and presented a paper on a low-latency distributed KVS for personalized content delivery, proposing a construction method that reduces the bandwidth cost of inter-node data synchronization by exploiting a client-centric consistency model. (Paper)
  • Proposed a method to improve DNS cache hit rate and response speed for distributed systems, receiving the Student Encouragement Award at the IPSJ National Convention; implemented and evaluated it as a CoreDNS plugin (dcache).
  • Technical verification through survey and implementation of distributed system related papers.

2018 - Present

Individual Developer

Personal Development / Activities

Product development and tool creation based on technical interests.

  • Construction and operation of a self-made system to streamline paper input (PDF/HTML Markdown conversion, translation, audio generation pipeline using VOICEVOX).
  • Development and operation of VRChat related tools (resize.gg, auto-rejoin tool, etc.).
  • Technical trial and error and output to solve daily problems.
  • Developing elastickv, an experimental open-source distributed KVS and FUSE filesystem used in my home lab.

2010 - Present
Third-Party Notices