Sium Km
Software Developer
9+ years exp
3+ projects
JavaScript
Java
Node JS
SQL
TypeScript
Kotlin
Python
UI Component Architecture: 5/10
Responsive & Cross-browser: 4/10
State Management & Data Flow: 4/10
Active 8 days ago
+250782344296 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Frontend UI engineer at a middle level specializing in building reusable form systems and client-side UI abstractions. The strongest proven skill is designing typed form models and reusable UI utilities, as shown by the form package configuration and comprehensive type model in aic-forms/src/interfaces/appInterface.ts and packaging in aic-forms/package.json. There is limited public evidence of large-scale performance benchmarking, accessibility audits or advanced server-side system design.
Technical skills
JavaScript
Java
Node JS• Middle
SQL
TypeScript• Senior • 7y+
Kotlin• Middle • 7y+
Python• Senior • 7y+
Node JS
Axios
Nest.JS• 7y+
Knex.js• 5y+
Python
Django• 9y+
FastAPI• 7y+
Databases
MySQL
PostgreSQL• 9y+
Couchbase• 7y+
Redis• 7y+
Frontend
Angular
GraphQL
Redux
React.js
Tailwind CSS
Vite
React Router
Vue.js• 5y+
DevOps
Azure
Chaos Engineering
CI/CD
Rest API
AWS• 7y+
Azure DevOps• 7y+
Docker• 7y+
GitHub Actions• 7y+
Grafana• 7y+
Jenkins• 7y+
Prometheus• 7y+
AI/ML
Hallucination
LLM
Claude• 3y+
Model Context Protocol
Mobile
MVP
Offline-First
Couchbase Lite• 7y+
React Native• 7y+
Android SDK• 6y+ • 3 projects
QA
Sentry• 7y+
Timeline
Senior Software Engineer (Full Stack Engineer & Platform)
•
Senior
One Acre Fund
•
Full-Time
Built and led internal Python/FastAPI tooling for support operations, providing structured REST APIs with role-scoped access and audit logging. Integrated Anthropic Claude to transform natural-language support requests into safe, structured database write operations while keeping deterministic mutation paths. Developed a NestJS/MCP agent for offline document diagnosis and fixes using Couchbase and Redis-backed per-session state. Implemented reliability practices including chaos and load testing plus automated performance/reliability reporting with Jenkins and observability tooling.
Python
FastAPI
TypeScript
Nest.JS
Model Context Protocol
Claude
Couchbase
Couchbase Lite
Redis
AWS
Docker
Jenkins
GitHub Actions
Azure DevOps
Sentry
Grafana
Prometheus
React Native
Kotlin
Front-End Engineer (Freelance)
•
Middle
ThinkMD HealthTech
•
Freelance
Contributed to a healthcare clinical assessment platform by building responsive front-end interfaces. Implemented Vue.js UI components and integrated them with backend data layers using Knex. Worked in a healthtech setting focused on accuracy and user trust.
Vue.js
Knex.js
Lead Full Stack Engineer & Tech Lead
•
Lead
GO Ltd
•
Full-Time
Architected and delivered the AgriGO digital agriculture platform from MVP to production as the main engineer. Designed the PostgreSQL schema and built a Django backend providing JWT-secured APIs, transactional workflows, and payment processing. Implemented a daily advisory engine used by end users and led the team scaling from solo development to small team leadership.
Djangosince 2017
PostgreSQLsince 2017
Contract Full Stack Engineer
•
Middle
RudFactory
•
Part-Time
Built a Django backend and PostgreSQL data model to automate logistics processes previously handled manually. Executed a zero-downtime migration from Excel to PostgreSQL and delivered the work ahead of the planned schedule. Supported the transition to a more reliable system for managing inventory records.
Django
PostgreSQL
Eritrea Institute of Technology
Bachelor's Degree •
Computer Science
Southern New Hampshire University
Bachelor's Degree •
Healthcare Administration
Middle Frontend Developer
Confidence: High UI Engineer
Frontend UI engineer at a middle level specializing in building reusable form systems and client-side UI abstractions. The strongest proven skill is designing typed form models and reusable UI utilities, as shown by the form package configuration and comprehensive type model in aic-forms/src/interfaces/appInterface.ts and packaging in aic-forms/package.json. There is limited public evidence of large-scale performance benchmarking, accessibility audits or advanced server-side system design.
UI Component Architecture
5/10
How interface parts are built
Evidence of a curated form/component library, typed interface design and custom input/drag sensors aimed at reuse and composition.
Evidence
aic-forms/package.json: library packaging, exports and build config for a reusable component package
aic-forms/src/interfaces/appInterface.ts: comprehensive enums, interfaces and question model used across the form system
aic-forms/src/ui/web/components/shared/DraggablePointerSensor.ts: custom Mouse/Touch/Keyboard sensor implementations
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive work spans web and native with breakpoints and Tailwind configuration; clear per-platform padding strategy in mobile code.
Evidence
loan_app/src/views/layouts/responsive.ts: platform-specific responsive size buckets and selection logic
aic-forms/tailwind.config.js: container, responsive screens and extended theme settings
moodhub/src/App.css: media queries and adaptive layout rules
Performance Optimization
2/10
Speed of the interface
Minor local optimizations and proper build tooling are present but there is no measured profiling, bundle analysis or advanced runtime performance work.
Evidence
moodhub/src/hooks/useDashboardStats.ts: useMemo usage to memoize derived dashboard computations
aic-forms/package.json: Vite and library build plugins indicating awareness of bundling and packaging
Accessibility & Semantics
3/10
Usable for everyone
Some accessibility-minded touches (focus-visible styles, keyboard sensor) exist but there is no clear ARIA strategy, CI a11y checks or accessibility audits.
Evidence
aic-forms/src/ui/web/components/shared/DraggablePointerSensor.ts: KeyboardSensor class for keyboard interactions
moodhub/src/presentation/components/Toast.css: focus-visible and keyboard-focus styling
State Management & Data Flow
4/10
Managing data in the app
Clear client-side state and data abstractions are implemented (IndexedDB wrapper, service layer, form evaluation), with unit tests for validators; lacks advanced server-state patterns like request cancellation or optimistic rollback.
Evidence
moodhub/src/db/database.ts: initDB, getDB and withStore wrapper around IndexedDB transactions
moodhub/src/services/mood.service.ts: transactional add/edit/get patterns with Promise-based request handling
aic-forms/src/utils/search.ts: evaluateFormula and nested content traversal for calculated fields and form logic
UX & Visual Polish
4/10
Look and feel quality
Good visual polish and UX messaging with localized strings and styled components; edge states are handled in logic but skeletons, undo or perceived-performance experiments are limited.
Evidence
moodhub/src/hooks/useDashboardStats.ts: explicit empty-state and insight messages used for UX edge cases
moodhub/src/presentation/components/Toast.css: visual styling for notifications
loan_app/src/assets/i18n/en.js: localized user-facing messages and error strings
Expertise
React• Middle
Frontend Architecture & Build Tools• Middle
PWA & Web APIs• Middle
Industries
Financial Services• Middle
Technologies
JavaScript
TypeScript• Senior • 7y+
Node JS• Middle
Vue.js• 5y+
Redux
GraphQL
Tailwind CSS
Angular
React.js
Vite
Axios
React Router
Recommendations
- Lead development of reusable form libraries and complex form UX including skip logic, calculated fields and validations.
- Build offline-capable client features and PWAs using the existing IndexedDB abstractions and service layers.
- Own mid-size UI feature delivery on web or React Native apps where strong typed models and validation logic are required.
Middle Game Developer
Confidence: Medium Generalist
Frontend TypeScript React developer (mid-level) specializing in building reusable UI libraries and form systems. The strongest proven skill is designing and testing form logic and data models as shown by the TypeScript interfaces and unit tests in the form library and the packaging configuration for distribution. There is little to no evidence of game-specific systems like rendering, physics, deterministic simulation, or multiplayer netcode in the public human-authored code.
Gameplay Systems & Mechanics
How game logic works
Not evidenced in public code
Graphics & Rendering
Drawing game visuals
Not evidenced in public code
Physics & Math
Game physics and math
Not evidenced in public code
Engine Proficiency
3/10
Skill with the game engine
Evidence of practical TypeScript/React engineering and library packaging for a frontend library, plus custom interfaces and build configuration beyond default templates.
Evidence
aic-forms/package.json: exports, publishConfig, peerDependencies and build scripts indicating library packaging intent
aic-forms/vite.config.ts: custom Vite config with dts and tsconfig-paths plugins
aic-forms/src/interfaces/appInterface.ts: comprehensive TypeScript interfaces and enums for form data model
Performance & Frame Budget
2/10
Keeping the game smooth
Some attention to runtime cost and async resource reuse is visible, but no advanced frame-budget profiling or zero-alloc hot-path optimizations.
Evidence
moodhub/src/hooks/useDashboardStats.ts: useMemo to avoid recomputing dashboard stats on each render
moodhub/src/db/database.ts: cached db variable and initDB to avoid reopening IndexedDB on each call
Content Pipeline & Tooling
3/10
Tools for game content
Clear work on a reusable UI library with tests and packaging which shows understanding of a content/tooling pipeline for web components.
Evidence
aic-forms/package.json: build/test scripts, vite-plugin-dts and publishing configuration
aic-forms/src/utils/__tests__/inputValidators.test.ts: unit tests for validators demonstrating test coverage
aic-forms/src/utils/__tests__/search.test.ts: unit tests validating search and content utilities
Expertise
Game UI/UX• Middle
Recommendations
- Develop and maintain TypeScript React component libraries and form systems for web products.
- Implement frontend features that require strong type models, validation logic, and unit testing.
- Ship web library packaging and CI-friendly builds for npm distribution, including type declarations and test coverage.
Junior Backend Developer
Confidence: Medium Generalist
Full-stack developer focused on Python/Django web apps and React Native frontends at a Middle level with strongest practical strength in data modeling and application code organization. The strongest proven skill is backend data modeling and query work backed by people/models.py (complex relations and validation) and a migration history in people/migrations. There is limited evidence of production-grade resilience, observability, API versioning, or distributed system design in the publicly visible code.
API Design
2/10
How well APIs are designed
Basic API usage is present (frontend service layer calling backend endpoints and a small JSON-returning endpoint) but there is no evidence of a deliberate API versioning strategy, idempotency handling, consistent error contract, or advanced pagination design.
Evidence
sammysium/loan_app/src/services/ServiceLoans.ts: submitNewLoan uses httpCalls.post to call EndPoints.makeALoanApplication with try/catch
sammysium/loan_app/src/services/httpCaller.ts: imports axios and provides the HTTP client layer
sammysium/familytree/people/views.py: add_location returns HttpResponse(json.dumps(form.errors), content_type='application/json', status=422) (small JSON endpoint)
Data Layer & Database
5/10
Working with databases
Clear data-layer work: domain models with relations and integrity checks, a migration chain, use of select_related to reduce N+1 problems and hand-written raw SQL for specific queries which shows attention to query shape and performance.
Evidence
sammysium/familytree/people/models.py: complex Django models with ForeignKey relations, unique_together and clean() validation logic
sammysium/familytree/people/migrations/0001_squashed_0007_auto_20150609_2101.py: migration chain and schema evolution present
sammysium/familytree/people/views.py: raw SQL queries using connection.cursor() and use of select_related('birth') to avoid N+1 queries
Scalability & Performance
2/10
Handling load and speed
Some attention to query performance and select_related usage exists, but there is no clear caching, queue-based decoupling, connection pooling configuration or measured performance optimizations for production scale.
System Architecture
3/10
Overall system structure
Reasonable module boundaries and separation of concerns (frontend service layer, HTTP caller, Django app structure) but no evidence of multi-service architecture, config/secret management, or system decomposition trade-offs beyond single-app modularity.
Evidence
sammysium/loan_app/babel.config.js: module-resolver aliases show deliberate frontend module boundaries (e.g. '@services', '@models')
sammysium/loan_app/src/services/ServiceLoans.ts and src/services/httpCaller.ts: separation of service layer and HTTP caller
sammysium/familytree/people/: conventional Django app layout (models.py, views.py, migrations) indicating modular server structure
Security & Auth
3/10
Protecting data and access
Basic security practices are present - decorators restricting staff endpoints and model validation are used - but there is limited evidence of robust auth lifecycle management (tokens, refresh/revocation), input sanitization at every boundary, dependency audit or secrets handling.
Evidence
sammysium/familytree/people/views.py: @user_passes_test(_staff_only) used to restrict admin actions and @public decorator for public endpoints
sammysium/familytree/people/models.py: clean() implements domain integrity checks to prevent invalid states
sammysium/familytree/people/views.py: raw SQL via connection.cursor() (e.g. surnames query) - indicates manual SQL usage without an obvious parameterized API surface for user input
Reliability & Observability
2/10
Stability and monitoring
Minimal reliability and observability patterns are visible: a few try/except logging points exist but there is no structured logging, metrics, retries with backoff, circuit breakers, or graceful shutdown logic in the server-side code analyzed.
Evidence
sammysium/loan_app/src/services/ServiceLoans.ts: catch blocks that log and rethrow (console.log(error)) but no structured logging or retry/backoff
sammysium/familytree/people/models.py: Location.save uses a try/except around geocoding and prints the exception rather than emitting structured errors or metrics
Expertise
Python• Junior
Databases & Vector Storage• Junior
Industries
Financial Services• Middle
Technologies
Python• Senior • 7y+
Java
Kotlin• Middle • 7y+
SQL
MySQL
PostgreSQL• 9y+
Redis• 7y+
Rest API
Nest.JS• 7y+
Azure DevOps• 7y+
GitHub Actions• 7y+
FastAPI• 7y+
Prometheus• 7y+
Azure
CI/CD
Couchbase• 7y+
Jenkins• 7y+
Django• 9y+
AWS• 7y+
Docker• 7y+
Grafana• 7y+
Knex.js• 5y+
Chaos Engineering
Recommendations
- Build Django web applications and REST/GraphQL endpoints that need solid data modeling, migrations and server-side business logic.
- Develop mobile-backend integrations and front-to-back service layers (React Native frontends calling backend services using an HTTP caller abstraction).
- Implement database-driven features that require schema evolution and hand-tuned queries or reporting (e.g. analytics endpoints, admin tooling).
- Work on full-stack feature delivery where you can own model, view and client service layers and iteratively harden error handling and observability.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: