Luswata Andrew
Software Engineer
SQL
Python
JavaScript
Node JS
TypeScript
Security & Auth: 7/10
API Design: 6/10
Data Layer & Database: 6/10
Active 1 day ago
+256 (761) 670111
Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
Backend API Engineer (senior-level) specializing in Convex-based server logic and secure role-based authorization; strongest at defining clear server-side authorization boundaries and projections to avoid PII leaks. The strongest proven skill is secure domain-driven Convex function design and admin-read shaping, as shown by convex/departmentMemberships.ts, convex/memberProfiles.ts, and convex/admin.ts. The public code does not evidence operational infra like horizontal scaling, worker queues, connection-pool tuning, or extensive automated performance testing.
Technical skills
SQL
Python• Middle
JavaScript• Middle
Node JS• Middle
TypeScript• Middle
Python
Flask
Node JS
Axios
Prisma
Databases
MySQL
PostgreSQL
MongoDB
Frontend
Framer Motion
Tailwind CSS
Three.JS
PostCSS
Radix UI
shadcn/ui
Anime.js
Recharts
Next.js
React.js
DevOps
GCP
Cloudflare
CI/CD
Docker
Git
Vercel
Rest API
Design
Figma
Framer
AI/ML
Claude
Claude Code
LLM
Timeline
Makerere University Kampala
Bachelor's Degree •
Software Engineering
Software Engineer & AI Engineer
•
Middle
AIBOS Uganda
•
Full-Time
Built and shipped an AI phone agent, covering prompt design, tool orchestration, and integration into live workflows. Integrated LLM capabilities into production systems, including structured document extraction pipelines with reviewer-in-the-loop validation. Delivered full-stack enterprise applications using Next.js, React, Node.js, and Python, and implemented RESTful APIs and third-party integrations to production standards.
TypeScript
JavaScript
Python
React.js
Next.js
Node JS
LLMsince 2024
Rest API
Flask
Prisma
PostgreSQL
Docker
Vercel
Git
Frontend Lead
•
Lead
AIBOS Uganda
•
Full-Time
Defined and documented company-wide frontend engineering standards, including component conventions, project structure, and code review expectations. Reviewed frontend work across teams and raised UI quality baselines for client-facing products. Ensured consistency of interface patterns across AIBOS projects.
Project Manager, Employee Management System (EMS)
•
Lead
AIBOS Uganda
•
Full-Time
Owned the end-to-end EMS product covering system architecture, roadmap, and delivery for a multidisciplinary engineering team. Translated Japanese leadership direction into a scoped architecture and phased execution plan. Shipped key data and modeling features including LLM-assisted CV extraction with human-in-the-loop review and implemented documentation and operational runbooks to enable safe pause/resume.
LLM
Software Development Intern
•
Junior
NOVA GENERATION LTD.
•
Internship
Led development of a CRM system by coordinating a team from design through deployment. Built responsive frontend interfaces using Next.js and integrated RESTful APIs against a Node.js/MongoDB backend. Supported end-to-end delivery during the internship period.
Next.jssince 2024
Node JSsince 2024
Rest APIsince 2024
Middle Backend Developer
Confidence: Medium API Engineer
Backend API Engineer (senior-level) specializing in Convex-based server logic and secure role-based authorization; strongest at defining clear server-side authorization boundaries and projections to avoid PII leaks. The strongest proven skill is secure domain-driven Convex function design and admin-read shaping, as shown by convex/departmentMemberships.ts, convex/memberProfiles.ts, and convex/admin.ts. The public code does not evidence operational infra like horizontal scaling, worker queues, connection-pool tuning, or extensive automated performance testing.
API Design
6/10
How well APIs are designed
Clear server-side API boundary with Convex queries/mutations, explicit authorization gates, and careful projection of sensitive fields to avoid PII leakage.
Evidence
convex/departmentMemberships.ts: listDepartmentMembers, listDepartmentMembersWithProfiles, addDepartmentMember, updateDepartmentMembership
convex/memberProfiles.ts: submitProfile, verifyProfile (server-side submission and verification flow)
convex/admin.ts: listUsers, getUserDetail (filtering, pagination and denormalized read shapes)
Data Layer & Database
6/10
Working with databases
Thoughtful use of indexed queries, narrow projections to limit data sent to clients, and idempotent seeding/migration-aware patterns indicate deliberate data-layer design and schema-evolution awareness.
Evidence
convex/departmentMemberships.ts: .withIndex(...) usage (by_departmentId_status, by_userId_status) to constrain queries
convex/memberProfiles.ts: listVerifiedMembersWithRoles returns narrow projections and performs server-side joins to avoid leaking full profiles
convex/contentSeed.ts: seedContent is idempotent and documents migration-safe seeding
Scalability & Performance
3/10
Handling load and speed
Some performance-aware code (parallel Promise.all, indexes) and idempotent seeds, but no explicit caching, queueing (beyond Convex queries), or measured throughput/connection-pool tuning in the human-authored code.
Evidence
convex/listDepartmentMembersWithProfiles (in departmentMemberships.ts): Promise.all to parallelize joined lookups
convex/departmentMemberships.ts: index-backed queries to avoid brute-force scans
convex/contentSeed.ts: idempotent seed workflow to avoid heavy repeated work on deploy
System Architecture
5/10
Overall system structure
Clear separation of concerns between auth, domain functions, and admin reads; deliberate enforcement of server-side authorization boundaries and small, focused Convex functions rather than monolith RPCs.
Evidence
convex/lib/authz.ts usage patterns surfaced across functions (requireUser, requireDepartmentHod, getAdministrationAuthorityOrNull) as the security boundary
convex/departmentMemberships.ts and convex/memberProfiles.ts: domain-specific mutations and queries encapsulated per-concern
convex/admin.ts: admin read functions (listUsers, getUserDetail) giving a separate surface for system-admin needs
Security & Auth
7/10
Protecting data and access
Strong authorization patterns, defensive checks, and deliberate projection to avoid exposing PII; authorization logic centralised and used consistently across mutations and queries.
Evidence
convex/lib/authz.ts references and usage in convex/departmentMemberships.ts (requireDepartmentAuthority, requireDepartmentHod) and convex/memberProfiles.ts (canManageChurchAdmin, getAdministrationAuthorityOrNull)
convex/admin.ts: requireSystemAdmin wrapper around sensitive admin actions (suspendUser, unsuspendUser)
convex/memberProfiles.ts: server-side verification flow (verifyProfile) separates verification from role grants and logs activity
Reliability & Observability
5/10
Stability and monitoring
Good observability and auditing (activity logs, logActivity calls), idempotent seeds and guarded reads improve reliability; operational patterns (retries/backoff, graceful shutdown) are not visible in the human-authored code.
Evidence
convex/admin.ts: hydrateActivity reads activityLogs and denormalizes events for observability
convex/memberProfiles.ts and convex/departmentMemberships.ts: repeated use of logActivity to record state changes
convex/contentSeed.ts: idempotent seed design reduces deployment friction and unexpected failures
Verified artifacts
Expertise
Microservices & API Architecture• Middle
Databases & Vector Storage• Middle
Technologies
Node JS• Middle
Rest API
Flask
Axios
Recommendations
- Develop Convex-backed role-based APIs and admin portals where strong server-side authorization and narrow projections are required (e.g., member-management, content admin).
- Lead schema-evolution and migration work that needs idempotent seeds and transitional unions; author the widen→migrate→re-tighten migration sequences and automated migration runners.
- Implement server-side media pipelines and signed-URL flows for mobile apps (R2 upload/gateway + signed display URLs) and extend the existing resolveMediaUrl patterns.
- Design secure, audited change workflows (activity logs + idempotent operations) for small-to-medium membership platforms with sensitive PII.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Frontend Developer
Confidence: Medium Fullstack
Fullstack engineer at a senior level specializing in secure, server-driven frontend architectures and Convex-backed platform work. The strongest proven skill is careful server-side authorization and schema migration, as shown by the getDepartmentAccess/authz gating and the membership/role migration patterns in convex/departmentMemberships.ts and convex/memberProfiles.ts. There is little or no original frontend component code, accessibility surface, or browser-level performance measurement in the human-authored files reviewed.
UI Component Architecture
How interface parts are built
Not evidenced in public code
Responsive & Cross-browser
Works on all screens and browsers
Not evidenced in public code
Performance Optimization
4/10
Speed of the interface
Demonstrates deliberate payload and round-trip reduction and batching on the server side (projections, Promise.all, collapsing dependent lookups); evidence is primarily backend-focused rather than measured frontend LCP/INP results.
Evidence
convex/departmentMemberships.ts: resolveRosterDepartment + comments and server-side collapse of client round trip to avoid an extra dependent fetch
convex/memberProfiles.ts: listVerifiedMembersWithRoles uses narrow projections, in-memory grouping and batching to reduce payload and avoid shipping sensitive fields
Accessibility & Semantics
Usable for everyone
Not evidenced in public code
State Management & Data Flow
4/10
Managing data in the app
Shows server-state discipline and careful authorization boundaries for reactive subscriptions, with explicit patterns to avoid throwing on sign-out and to centralize enforcement on server functions rather than middleware.
Evidence
convex/departmentMemberships.ts: getDepartmentAccess enforces activeRoles server-side and documents why middleware was not sufficient
convex/memberProfiles.ts: submitProfile writes self-service departmentMemberships and verifyProfile gates verification; comments document why roster vs role assignments are orthogonal
UX & Visual Polish
Look and feel quality
Not evidenced in public code
Expertise
React• Middle
Frontend Architecture & Build Tools• Middle
Web Performance & Optimization• Middle
Technologies
GCP
Tailwind CSS
Next.js
Vercel
Figma
Three.JS
Prisma
Git
Docker
React.js
Framer
Radix UI
PostCSS
shadcn/ui
Framer Motion
Anime.js
Recharts
Recommendations
- Lead work that requires secure server-side authorization boundaries and schema evolution - backend-for-frontend, Convex functions, and migration scripts.
- Improve portal-first performance and payload reduction for admin and mobile by extending the existing server-side batching and projection patterns into coordinated client/server contracts.
- Own backend-driven UI features where authz, data-safety and live subscriptions matter (admin panels, member verification workflows, content gating).
- Avoid hiring for pure accessibility- or component-library-heavy tasks unless complemented by a dedicated UI engineer; ask for explicit frontend component ownership and browser tests first.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle QA Engineer
Confidence: Medium Generalist
Full-stack product engineer focused on mobile, web-admin and a Convex-backed realtime backend, Senior level with strong system hardening and integration instincts. The strongest proven skill is backend authorization and data modelling as demonstrated by convex/lib/authz.ts and convex/departmentMemberships.ts which show careful gate placement, migration-safety and audit logging. Public code does not show a developer-owned automated test-suite, contract tests, or formal load-test harnesses.
Test Automation Frameworks
2/10
Building automated tests
Test automation framework evidence is minimal; the codebase exercises linting and tsc checks and has CI/deploy scripts, but there are no developer-authored test fixtures, isolated test servers, data factories, or mock server implementations visible in the human-authored code.
Evidence
apps/mobile/package.json: lint script and Expo runtime checks referenced
apps/admin/package.json: build/preview/deploy scripts showing CI/deploy hooks (opennextjs-cloudflare)
convex/_generated/server.d.ts and convex functions: validators used via convex/values (argument validation instead of test fixtures)
Test Coverage & Strategy
2/10
What and how to test
Test coverage and strategy are not evidenced by automated suites; product code shows thoughtful negative-path handling and validation but there are no unit/property-based tests, mutation testing, or risk-tagged test suites present in the human-authored files.
Evidence
convex/memberProfiles.ts: Zod-style validators and server-side validation in submitProfile/verifyProfile
convex/departmentMemberships.ts: explicit error handling and guard checks in add/update/remove mutations
API & Integration Testing
4/10
Testing how parts work together
Strong API/integration engineering is evident (schema evolution, migrations, R2 uploads, push-notifications wiring and signed-url resolution), but there is little evidence of contract test tooling (pact/schemathesis) or containerized integration tests; integration is implemented and validated via schema/migration code and gated Convex queries.
Evidence
convex/uploads.ts (storage gateway) and convex/lib/media.ts: signed URL resolution and object-key storage pattern
apps/mobile/lib/r2-upload.ts: client-side upload flow to R2 (PUT → syncMetadata)
convex/convex.config.ts import list: r2 and expo-push-notifications registrations referenced
Performance & Load Testing
2/10
Testing speed under load
There is visible performance awareness and targeted optimizations (bundle delta measurement, fewer round trips), but no formal load or SLO-driven performance tests (k6/locust) or automated soak/spike scenarios.
Evidence
apps/admin/middleware.ts: reduced network round trips and comments describing middleware bundle measurements
apps/admin/app/(admin)/admin/year-planner/calendarGrid.ts: specialized calendar/grid helpers intended to reduce client-side work
Bug Reporting & Analysis
3/10
Finding and describing bugs
Clear evidence of bug analysis and corrective commits in code comments and function-level hardening (authorization fixes, schema migration patterns), but external reproducible bug reports or attached issue-to-fix artifacts (public tracker links with MR) are not present in the human-authored code bundle.
Evidence
convex/getDepartmentAccess (inside convex/departmentMemberships.ts): in-code root-cause reasoning for moving the authorization boundary
convex/memberProfiles.ts: migration-safe leadership status handling and comments explaining transitional status widening
CI Test Integration
2/10
Running tests automatically
CI/test integration exists at the project level (build/deploy scripts, EAS build workflows referenced in PR text), but the human-authored files do not show an integrated matrix of automated tests in CI, per-test artifact capture, or quarantine/conditional-shard mechanics for flaky tests.
Evidence
package.json (root and apps/admin): scripts for build, preview and deploy (opennextjs-cloudflare) showing CI-oriented commands
apps/mobile/package.json: 'lint' and Expo scripts used as part of local CI checks
Expertise
API Testing & Contract Validation• Middle
Performance & Load Engineering• Middle
Technologies
JavaScript• Middle
TypeScript• Middle
CI/CD
Cloudflare
Recommendations
- Lead feature development that touches backend authorization, data migrations, and real-time Convex functions (secure APIs, schema migrations, R2 integration).
- Own cross-surface integrations where mobile and web share semantics (push registration, signed-media URLs, profile verification workflows).
- Drive performance optimizations that are low-risk and measurable (bundle-splitting, auth round-trip collapse, first-paint byte reductions) and codify measurement in CI.
- Add automated test infrastructure: unit tests for Convex helpers, contract/contract-like checks for public query shapes, and a lightweight integration environment for R2 and push paths.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: