Working as an embedded enabling engineer across several product teams in the medical-institution business unit. With "maximizing the delivery of user value" as the goal, I work backward from each team's stage toward it, through SLI/SLO definition, automated error triage, and developer productivity.

• Core implementer on the re-architecture of the toC symptom checker (~10M MAU) from Rails to Node.js (Nest.js + GraphQL), leading the migration implementation, load testing, and performance tuning
  • Agreed the performance baselines to preserve with the owning product team, then built a k6-based load-testing harness and scenarios around them. This surfaced performance regressions that only appear at production data volumes, which unit-level testing kept missing, and they were fixed before cutover
  • Turned those findings into an internal ISUCON event (~10 participants), and shipped the migration with user-perceived question-to-question latency cut to ~40% of the original at the median
• Re-architected the LLM batch platform with a preprocessing layer that curates the information handed to the model. Using past execution logs to enrich what it can reason about cut token consumption by ~40%, kept the workload under token-usage caps as volume grew, and made re-runs cheap and reliable
• Built a Sentry-tag-driven LLM agent error-routing layer so production errors reach the engineers who own them, cutting incident rates and speeding up resolution of browser- and environment-specific bugs
• Built a Claude-Code-driven dev-environment bootstrap that turned a ~3-day onboarding into a mostly hands-off ~30-minute setup

Embedded part-time on the frontend team of LIPS, a cosmetics app. Three compounding problems - missing tests, slow pages, and weak error triage - are attacked by making improvement work scale through AI agents, and I own that platform work from design through implementation.

• Built the measure-improve-verify loop that agents run on: RUM instrumentation, framework and library groundwork, and verification harnesses, so an agent can drive the loop safely
  • On top of it, performance work, large framework and library upgrades, and bug triage run continuously. A Session Replay mechanism was set up alongside to speed up triage
• Since joining, the team's commit throughput has roughly doubled, pages rated red on LCP / FCP are down to a third, and the bug rate is down to a half to a third

As a Product Engineer, I was involved in web development for peripheral products of Nikkei Digital. While developing frontend and BFF layers, I also contributed to technical infrastructure improvements, such as introducing mechanisms to mechanically enforce codebase constraints aligned with business domains and improving build speed of component catalogs.

Later, as a Platform Engineer, I worked on developing and improving the technical infrastructure of Nikkei Digital Web, solving technical challenges in product development and enabling peripheral web product development.

• Led the Next.js migration of applications with legacy and unmaintainable technical infrastructure
  • Achieved gradual migration by refreshing at the infrastructure level, preventing migration-related incidents
  • Realized speedy development through migration to modern technical infrastructure, along with user experience improvements through specification reviews
  • Led design and development with thick mechanical constraints to eliminate development dependencies
• Consolidated common data hardcoded across nearly 20 microservices into a single API, reducing deployment frequency
• Led the monorepo integration of nearly 20 poly-repositories that were essentially the same product with many shared processes
• Improved authorization processing in Nikkei Digital to maintain service availability during ID infrastructure failures
• Improved Nikkei Digital's build infrastructure, achieving nearly 35% improvement
• Established a foundation for static testing in Nikkei Digital's CDN infrastructure

And more.

Joined as a contractor alongside my full-time role at Nikkei, driving technical migrations during Ubie's growth phase.

• Drove the Node.js migration of the toC symptom checker's backend. The project moved a Kotlin-based modular monolith (20-30 modules) to Node.js to unify the company-wide tech stack, and I owned the migration implementation
  • I also built tooling that automated a migration chore taking 30-40 minutes per query, removing that work for roughly 200 GraphQL queries. The migration shipped over about a year
• Consolidated the frontend platform, merging two Next.js applications that lived in separate repositories into one
  • As part of it, the CSS library was reworked from Tailwind CSS to CSS Modules. I built an AST-based codemod that resolves what Tailwind would have produced and emits it as CSS Modules, migrating ~1,000 components with roughly 80% automation coverage
  • A compatibility-verification harness was set up alongside it so the migration could proceed safely, and it finished with zero migration-caused bugs

Supported the monorepo integration of remaining yarn-based workspaces within a pnpm-based monorepo structure and assisted with the migration to ESLint FlatConfig.

I conducted a Proof of Concept (PoC) for an on-request build foundation for 3rd party scripts. The content of these scripts, delivered via Plaid, varied based on customer settings. While previously built whenever customer settings changed, I leveraged Edge Computing to enable on-request builds and cache them on the CDN. This approach allowed for rapid reflection of customer configurations, simplified the system, and achieved faster loading times. My work involved running web application bundlers and compilers on Cloudflare Workers, optimizing them for low memory consumption and high speed within the CDN environment.

I also led the establishment of an on-browser/QA testing foundation. The complex build system for our 3rd party scripts made it difficult to test their functionality holistically or in real environments. Given their direct impact on customer business, high SLOs were required, leading to a "release phobia" due to the difficulty of testing and the severe consequences of failures. To overcome this, I built a robust testing foundation. First, I streamlined the complex build system. Then, I developed a framework where customer configurations could be defined as JSON within test scenarios. This allowed scripts to be built during tests and validated directly in a browser using Playwright, enabling continuous and automated testing of critical functionalities in a realistic environment, thereby enhancing application stability.

Furthermore, I contributed to building the QA testing foundation. By utilizing VCL within the Fastly CDN layer, I developed a mechanism that allowed us to redirect scripts to a development environment via cookie-based control, directly on the actual homepages of customers who had implemented our 3rd party script. This enabled real-world QA testing, making it easier to identify and resolve issues that only occurred in specific environments or usage patterns. These initiatives significantly boosted the application's reliability. Finally, I automated our deployment flow. The complexity of our build process meant the deployment flow was equally intricate, requiring all components to be deployed to update the service. Furthermore, deployment targets were managed across disparate repositories, necessitating complex cross-repository modifications and resulting in high operational costs. Recognizing that these tasks were entirely automatable, I implemented CI/CD-driven automation. This transformed a nearly 10-minute manual release process into a one-click operation, vastly improving field operations.

I focused on optimizing third-party scripts, which significantly improved user experience. The plugin system's architecture inherently supported small file sizes, but I took it further by implementing additional tuning that reduced the file size by over 5%. I achieved this by:

• Revisiting the transpiler targets for dependent libraries.
• Removing unnecessary polyfills.
• Refining and validating minifier settings.
• Restructuring the codebase to maximize tree-shaking and minification effectiveness.

To prevent future bloat, I also introduced a mechanism in our CI/CD pipeline to notify developers of file size changes, fostering a culture of file size awareness among the team.

I spearheaded the technical foundation overhaul of hack.nikkei.com. The outdated infrastructure had degraded developer experience, impacting technical blog authoring, and poor user experience due to performance issues. I re-architected the platform to a Next.js-based foundation, significantly improving the authoring experience and page load speeds. This initiative enabled the publication of Advent Calendars and presentation materials directly on hack.nikkei.com, enhancing our technical brand.

I also led the development of the news video generation feature for Nikkei Wave (https://apps.apple.com/jp/app/nikkei-wave/id1521762085). I built the frontend platform responsible for rendering news videos using extensive CSS animations, based on JSON data from the backend that specified the order, text, background, and animation for each segment. I engineered a foundation that allowed for independent and declarative configuration of complex animations, making it easy for anyone to develop new animations. Furthermore, I established static linters and a component catalog to facilitate regression detection.

The high quality and extensibility of these animations, coupled with the ability to generate animated content for almost every article, earned significant praise both internally and externally. This success ultimately led to the videos being distributed to Haneda Airport signage.

Lastly, I conducted technical validation for Fastly Compute. I explored the feasibility of running tensorflow.js on the Fastly Compute platform to achieve edge computing-based recommendations for anonymous users, leveraging their User Agent and IP information.

I revamped the UI of an internal frontend application. Recognizing that the complex functionality led to a "power-user-only" UI, I gathered user feedback to identify pain points. My solution simplified the UI while introducing a UNIX-like directory structure for a more familiar and improved user experience. Additionally, I researched web and frontend trends, reporting on their potential impact on our internal products.

I teamed up with other interns to develop an extension for kintone. I led the project from planning to technology selection, considering non-functional requirements for kintone extensions, and opting for minimal bundle-size technologies like lit-html.

As a Frontend Engineer, I developed screens for Wantedly, focusing on complex frontend implementations like incremental search. I collaborated closely with designers to ensure a rich user experience and robust developer experience through sound component design.

I developed a SNS like web application with the other internship team. This internship was a form of a hackathon. As a Frontend Engineer, I led user experience design and frontend application development. I also collaborated with backend developers on API design, ensuring a RESTful approach, and received an award for the design.

I developed HR web application. I implemented some features including it's frontend with CodeIgniter & jQuery.