Akio Ito
Full Stack Developer
10+ years exp
4+ years ML exp
JavaScript
TypeScript
Node JS
Go
Python
Java
Data Layer & Database: 5/10
Security & Auth: 5/10
API Design: 4/10
Active 23 days ago
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic frontend engineer at roughly a middle level who builds admin-facing applications and supporting utilities for an iGaming platform. The strongest proven skill is building robust mock/server-state layers and data utilities - evidenced by src/services/mock/mockData.ts which implements a deterministic mock API router and rich data generators used across the admin UI. The public code shows strong visual/theming and data-shaping work but lacks explicit evidence of advanced state-machine logic, request-cancellation/race handling, comprehensive automated tests, or focused a11y implementations.
Technical skills
JavaScript
TypeScript• Middle • 10y+
Node JS• Middle • 8y+
Go• Senior • 8y+
Python• Senior • 5y+
Java• Middle • 5y+
Node JS
Axios
Express
Python
Asyncio
Celery
Django
FastAPI• 8y+
Java
Spring Boot
Databases
Apache Kafka
FAISS
MySQL
pgvector
Weaviate
PostgreSQL• 10y+
Redis• 10y+
Pinecone• 5y+
Frontend
GraphQL
Lighthouse
Material UI
Tailwind CSS
PostCSS
Redux
Redux Toolkit
Zod
autoprefixer
Angular• 10y+
Next.js• 5y+
React.js• 5y+
DevOps
Azure
CI/CD
Git
Grafana
Jenkins
Kubernetes
Prometheus
Terraform
Vector
Rest API
Docker Compose
AWS• 8y+
gRPC• 8y+
OpenTelemetry• 7y+
Docker• 5y+
GitHub Actions• 5y+
QA
Pytest
Vitest
Supertest
Jest• 5y+
Selenium• 5y+
AI/ML
Anomaly Detection
Copilot
Fine-tuning
LlamaIndex
LLM
RAG
Semantic Search
vLLM
LangChain• 4y+
Mobile
Clean Architecture
JUnit• 5y+
Cybersecurity
Keycloak
Timeline
Senior Fullstack Developer
•
Senior
Switch Case
•
Full-Time
Led a team of engineers delivering distributed backend services in Python and Go, alongside micro-frontend modules using Next.js and React. Built an LLM-powered assistant for runbook parsing and incident analysis using LangChain and Pinecone, improving incident response outcomes. Designed a unified CI/CD pipeline with GitHub Actions and Docker across multiple service stacks and improved release speed and test coverage. Enhanced Next.js performance using SSR/ISR patterns and supported QA with contract and Selenium regression testing.
Python
FastAPI
Go
gRPC
Next.js
React.js
LangChain
Pinecone
GitHub Actions
Docker
Java
JUnit
Jest
Selenium
Senior Fullstack Developer
•
Senior
RVC Group
•
Full-Time
Migrated a legacy monolith to a microservices architecture using FastAPI and Go for backend services, with Angular and Node on the frontend. Built embedding-based search and recommendation features backed by vector indexes, improving internal search relevance and conversion. Implemented PostgreSQL on AWS with OAuth2 and end-to-end observability using OpenTelemetry, contributing to fewer security incidents. Mentored engineers on Agile practices and clean architecture to increase sprint velocity.
FastAPIsince 2018
Gosince 2018
gRPCsince 2018
Angular
Node JS
Pineconesince 2018
PostgreSQL
AWS
OpenTelemetry
Senior Fullstack Developer
•
Senior
Earth 2
•
Full-Time
Optimized PostgreSQL performance and implemented a Redis caching layer to reduce API latency at large user scale. Integrated AI-powered product features such as clinical notes summarization and multilingual translation via cloud AI services. Developed healthcare administration portals using AngularJS and TypeScript while maintaining high availability and strong Lighthouse performance.
PostgreSQLsince 2016
Redis
Angularsince 2016
TypeScript
Chiba University
Bachelor's Degree •
Computer Science
Middle Backend Developer
Confidence: Medium API Engineer
A backend-focused API engineer at a mid-level who produces clear controller-service-repository and domain/application/infrastructure separations across Go and TypeScript services. The strongest proven skill is building reliable transactional APIs with idempotency and DB integrity, evidenced by the preference-service idempotency implementation and the Go repository transaction logic (preference-repository.ts and user.repository.go). The public code lacks advanced operational/resilience work (timeouts, retries/backoff, graceful shutdown) and there is no multi-service orchestration or long migration history exposed.
API Design
4/10
How well APIs are designed
API design shows deliberate choices (idempotency keys, consistent error responses, cookie + Authorization header support) but lacks formal versioning, documented error contract, or advanced patterns like typed OpenAPI-driven contracts and global pagination strategy.
Evidence
bit-pal/notification-preference-service/src/infrastructure/repositories/preference-repository.ts - idempotencyKey handling in updatePreferences
bit-pal/notification-preference-service/src/test/integration.test.ts - idempotency integration test verifying single application of idempotency key
bit-pal/gin-next/server/controllers/user.controller.go - utils.ErrorResponse usage and cookie/Authorization fallback for tokens
Data Layer & Database
5/10
Working with databases
Data layer displays sound practices - parameterized SQL, explicit transactions, GORM model hooks and DB-level enum creation - but I saw no long migration chain or evidence of careful tuning/indices beyond standard usage.
Evidence
bit-pal/gin-next/server/repositories/user.repository.go - tx.Transaction usage for image uploads and multiple DB operations
bit-pal/gin-next/server/models/user.model.go - BeforeCreate/BeforeSave hooks and CREATE TYPE user_role SQL
bit-pal/notification-preference-service/src/infrastructure/repositories/preference-repository.ts - parameterized queries, ON CONFLICT upserts and idempotency log table usage
Scalability & Performance
3/10
Handling load and speed
Some scalability primitives exist - DB pooling and batched client-side pagination - but no caching/invalidation strategy, no queue-based decoupling, and no load-test/benchmark artifacts were found.
Evidence
bit-pal/notification-preference-service/src/infrastructure/db/pool.ts - getPool and withTransaction (connection pooling pattern)
bit-pal/User-Management-Dashboard/src/services/users.ts - batched pagination loop (getAllUsers) and careful page handling
bit-pal/gin-next/client/api/index.ts - (client-side) use of fetch/axios with query helpers (evidence of thinking about pagination/fetch)
System Architecture
4/10
Overall system structure
Clear module boundaries and a two-tier service/repository/controller layering in Go and a domain/application/infrastructure split in the TypeScript service show deliberate architecture decisions, but there is no multi-service orchestration, service mesh, or cross-service contracts documented.
Evidence
bit-pal/gin-next/server/controllers/user.controller.go + bit-pal/gin-next/server/services/user.service.go + bit-pal/gin-next/server/repositories/user.repository.go - classical controller-service-repository separation
bit-pal/notification-preference-service/src/application/preference-service.ts + src/infrastructure/repositories/preference-repository.ts + src/domain/preference-resolver.ts - domain/application/infrastructure separation
bit-pal/gin-next/server/config/config.go - global config singleton with sync.Once and RWMutex showing conscious config-management choices
Security & Auth
5/10
Protecting data and access
Authentication and input-safety are handled (JWT parsing, refresh token lifecycle, password hashing hooks, parameterized SQL), showing reasonable security awareness; some hardening is missing (secure cookie flag usage, secrets rotation or vault integration not present).
Evidence
bit-pal/gin-next/server/controllers/user.controller.go - JWT parsing, cookie + Authorization header handling for refresh/access tokens
bit-pal/gin-next/server/models/user.model.go - BeforeSave hash of passwords via utils.HashPassword
bit-pal/notification-preference-service/src/infrastructure/repositories/preference-repository.ts - parameterized queries (no string interpolation) and idempotency log insertion
Reliability & Observability
4/10
Stability and monitoring
Reliability practices include transactions, idempotency, and integration tests with DB setup/teardown plus structured logging; however there are few operational resilience patterns (no retries with backoff, circuit breakers, timeouts, or graceful shutdown code visible).
Evidence
bit-pal/notification-preference-service/src/test/integration.test.ts - integration tests exercising DB and idempotency behaviours
bit-pal/notification-preference-service/src/application/preference-service.ts - logger.info usage and creation/merge logic to ensure defaults
bit-pal/notification-preference-service/src/infrastructure/repositories/preference-repository.ts - transactional updates and idempotency to ensure consistent state
Expertise
Go Development• Middle
Node.js• Middle
Microservices & API Architecture• Middle
Databases & Vector Storage• Middle
Technologies
AWS• 8y+
Gin• mentioned only
Recommendations
- Own APIs that require transactional integrity and idempotent updates - implement feature work that updates user state with strong DB guarantees (idempotency, upserts, transaction boundaries).
- Improve operational resilience for services - add request timeouts, retry with backoff where appropriate, graceful shutdown, and documented SLI/SLO metrics and health checks.
- Harden security and secrets - enable secure cookie flags in production, introduce secrets rotation/vault integration, and add threat-model tests for auth flows.
- Expand test and migration hygiene - add end-to-end performance/load tests, and maintain a migration chain with readable change history and automated CI migration checks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: High App Engineer
A pragmatic frontend engineer at roughly a middle level who builds admin-facing applications and supporting utilities for an iGaming platform. The strongest proven skill is building robust mock/server-state layers and data utilities - evidenced by src/services/mock/mockData.ts which implements a deterministic mock API router and rich data generators used across the admin UI. The public code shows strong visual/theming and data-shaping work but lacks explicit evidence of advanced state-machine logic, request-cancellation/race handling, comprehensive automated tests, or focused a11y implementations.
UI Component Architecture
3/10
How interface parts are built
Component boundaries and design-system choices are present but limited to configuration and data-shape files rather than a clear custom component library; composition and custom hooks are not visible in the analyzed human-authored files.
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive rules and breakpoint-aware assets are explicitly configured (custom screens, many Tailwind tokens) and a Framer-generated landing CSS includes breakpoint visibility helpers, showing attention to multiple viewports.
Performance Optimization
2/10
Speed of the interface
Small, practical performance-minded techniques appear (deterministic mock generation and limited token reuse) but there is no measurable performance work, bundle analysis, virtualization, or advanced client-side optimisation in the reviewed human-authored files.
Accessibility & Semantics
2/10
Usable for everyone
Some accessibility-friendly patterns exist implicitly (semantic table column definitions and responsive CSS), but there is no explicit ARIA handling, keyboard/focus management, or axe/CI a11y checks visible in the human-authored artifacts.
State Management & Data Flow
3/10
Managing data in the app
There is clear evidence of server-state discipline in the form of a local mock API router and structured pagination/series helpers, and the project lists Redux/RTK in package.json, but advanced client-side state strategies (cancellations, optimistic updates, state machines) are not present in the reviewed files.
Evidence
bit-pal/gambling_admin/src/services/mock/mockData.ts: getMockResponse() router implementing paginated endpoints and time-series generators
bit-pal/gambling_admin/package.json: dependencies include @reduxjs/toolkit and react-redux (project-level state management)
bit-pal/gambling_admin/src/redux/store.ts: import lines for reducers (auth.reducer, statistics.reducer, modal.reducer) referenced in top-level store
UX & Visual Polish
4/10
Look and feel quality
Significant visual polish and UX scaffolding is present - a comprehensive Tailwind theme, many spacing tokens and a Framer landing page with fine-grained styles - but much of the visual output appears template/framer-generated rather than bespoke interaction work (e.g., skeletons, undo, edge states).
Evidence
bit-pal/gambling_admin/tailwind.config.ts: very large theme, spacing and animation tokens indicating careful visual system planning
bit-pal/medvi-landingpage/public/styles.css: detailed Framer CSS with typography and breakpoints
bit-pal/gambling_admin/src/config/columns.ts: extensive column metadata used for UX-consistent tables
Verified artifacts
Expertise
React• Middle
Modern Web Frameworks• Middle
Frontend Architecture & Build Tools• Middle
Industries
Gaming• Middle
Technologies
JavaScript
Node JS• Middle • 8y+
Redux
GraphQL
Tailwind CSS
Next.js• 5y+
Express
Angular• 10y+
React.js• 5y+
Axios
Material UI
PostCSS
Zod
Redux Toolkit
autoprefixer
Lighthouse
Recommendations
- Lead development of admin dashboards and analytics pages that consume server-state - implement paginated tables, charts and provider dashboards (use the existing mockData router to iterate rapidly).
- Build integrations and API-contract work (Next.js + API routes or an Express BFF) for crypto transactions and payouts where the existing mock router can be replaced by real endpoints.
- Productize utilities and formatters in src/utils (date, currency, address parsing) into a small shared library and add unit tests for edge cases and timezone logic.
- Improve frontend resilience by adding request cancellation, optimistic update patterns and a small state machine (XState or similar) around complex flows like payouts/withdraw approvals.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: Medium API QA Engineer
A practical middle-level engineer focused on API services and integration testing. The strongest proven skill is API integration testing and server-side idempotent update handling, demonstrated by the integration test suite (src/test/integration.test.ts) exercising repository transactions and idempotency. There is limited evidence of CI/test-engineering maturity, contract testing, performance testing, or advanced test infra patterns such as sharding, testcontainers or mutation testing in public code.
Test Automation Frameworks
5/10
Building automated tests
Solid integration test harness with Vitest and Supertest and explicit test DB setup and teardown; lacks advanced fixtures, factories, mock servers with business logic, and parallelization strategies.
Test Coverage & Strategy
6/10
What and how to test
Tests include meaningful negative-paths and boundary scenarios (quiet hours, global policy, idempotency) and assert exact failure reasons; no evidence of risk-based tagging or mutation/property-based testing.
API & Integration Testing
6/10
Testing how parts work together
Good API and integration coverage: Supertest-driven integration tests exercising DB-backed repositories, transactions and idempotency; no contract-testing tooling or explicit schema-validation libraries observed.
Performance & Load Testing
Testing speed under load
Not evidenced in public code
Bug Reporting & Analysis
Finding and describing bugs
Not evidenced in public code
CI Test Integration
Running tests automatically
Not evidenced in public code
Expertise
SDET & Test Engineering• Middle
Technologies
Go• Senior • 8y+
Java• Middle • 5y+
TypeScript• Middle • 10y+
Selenium• 5y+
Docker Compose
Spring Boot
Jest• 5y+
Pytest
Vitest
Supertest
Recommendations
- Build and maintain backend REST/HTTP services with full integration tests and DB fixtures (Node.js/TypeScript + PostgreSQL) - extend the existing test DB setup into reusable factories.
- Develop API contract tests and schema validation (e.g., OpenAPI-based or Schemathesis) to make integration assertions explicit between services.
- Implement CI test pipelines with selective runs, artifact collection, and per-test retry/quarantine rules to improve reliability of integration tests.
- Expand test infrastructure with containerized integration (testcontainers or Docker Compose orchestration) and add basic load/threshold checks for critical endpoints.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: