Technical stack

The tools, and what I do with them

What I actually do with each tool. No percentages, no seniority badges.

Backend

Node.js: The runtime behind every service I run in production: banking API servers, scheduled jobs, integration scripts.
NestJS: Structures my APIs into modules: dependency injection, auth and permission guards, input validation.
Python / Flask: Small standalone services and APIs, where a self-contained component beats adding another module to the main app.

React: Business and back-office interfaces wired to the APIs, reusable components and client-side state.
Angular: Structured internal banking applications: complex forms, administration screens, multi-step operational processes.
Remix: Server rendering and per-route data loading, for interfaces where time-to-screen matters.
TypeScript: Typed end to end, from the API contract through to the component, on web and mobile alike.

React Native: The three apps I write, publish and maintain myself on Google Play.
Expo / Expo Router: Builds, navigation, updates and store releases, plus access to native capabilities without leaving the development flow.
Offline-first: Local persistence, deferred sync queues, an app that stays fully usable in airplane mode.

REST: Resource design, versioning, error codes and documented contracts for the teams consuming my APIs.
GraphQL: Schemas and resolvers where the client needs to compose its own query rather than receive a fixed payload.
Third-party connectors: Integrating external services into banking applications: data exchange, outbound calls, error handling and retries.
Postman: Test collections, contract checks and shared workspaces with the teams on the other side of the API.

PostgreSQL: The primary database behind my banking work: modelling, relations, integrity constraints, indexes, queries.
MySQL: Relational databases on existing projects and environments: queries and schema changes.
MongoDB: Document storage where the data does not fit a relational model naturally.
Relational modelling: Turning business rules into entities, relations and constraints before development starts.
Access control (RBAC): Roles, user profiles and per-resource permissions, enforced at the API as well as in the interface.
Application security: Input validation, authentication and data separation between profiles, to banking requirements.

Git / GitHub: Branching strategy, merge requests and code review as daily practice.
GitHub Actions: Pipelines that run the tests, build the application and publish the images.
CI/CD: The full chain from commit to server: tests, build, deploy, with nothing released by hand.
Docker: Containerising applications and their dependencies so the same image runs locally and on the server.
Linux: The deployment servers: configuration, services, logs, releases.