john omotoye

• Designed and shipped 5 production RESTful APIs covering Interbank Transfer, Intra-bank Transfer, Balance Enquiry,
Name Lookup, and Statement Generation. Each API came with documented request/response contracts, a
consistent error taxonomy, and security headers baked in — the approach was later adopted as the teams standard
for new API work.
• Set up OAuth2 authentication and TLS encryption across all transaction endpoints, with structured audit logging on
top. This brought the platform into full ISO 20022 and CBN regulatory compliance and removed the manual
compliance review steps that had been creating gaps.
• Ran UAT across three cross-functional teams, working through transaction flow validation, defect triage, and
stakeholder sign-offs. All 5 APIs made it through to production as a result.
• Used AI-assisted analysis to review vulnerabilities in four production systems: QIP, CRM, Ebills Integration, and Swift
Telex Notification. The reviews were aligned to OWASP standards and caught authentication issues, injection risks,
and data-exposure problems before any of these went live.

• Built bulk data ingestion pipelines handling millions of telecom records a day. Reliability was the main concern, so
retry policies, dead-letter queues, and idempotency checks were all built in from the start — no data loss even
when things failed upstream.
• Worked on the core backend services in .NET Core, PostgreSQL, Quartz.NET, and RabbitMQ — the combination
handled job scheduling and async processing at scale for a large telecom billing system.
• Designed the event-driven architecture using RabbitMQ to separate out 5+ services that had been tightly coupled.
Getting rid of the synchronous bottlenecks made a real difference to throughput when the load spiked.

• Built multi-level transaction approval and authorisation workflows in ASP.NET Core. Role-based access control and
segregation of duties were key requirements from the security side, and both were fully implemented.
• Replaced synchronous transaction processing with an async messaging approach using RabbitMQ. This separated
four tightly coupled banking services and noticeably improved throughput and resilience under concurrent load.
• Built an immutable audit trail service that recorded every stage of a transactions lifecycle: creation, approval,
rejection, and reversal. This gave the compliance team real-time reporting and made forensic tracing
straightforward when regulators needed it.
• Used AI tools alongside .NET Core to build and ship the Domestic Transfer platform — a microservices suite
covering Bulk NEFT Outward, Single NEFT Outward, Payment Processing, NEFT Return, and NEFT Reversal. The
platform went live under real banking load and met all payment-rail regulatory requirements.

• Designed and delivered a high-performance merchant application in .NET Core, SQL Server, Dapper, and RabbitMQ.
Query optimisation, connection pooling, and caching brought average API response time down by 30%.
• Pushed DDD, Clean Architecture, and SOLID principles across the team, which cut down service coupling
significantly. The result was 6+ microservices that could be deployed independently without anything breaking.
• Took ownership of Azure DevOps CI/CD pipelines across the microservices — automated build validation, test
gating, staged deployments. Manual release steps were mostly eliminated, and deployment time for the team
dropped noticeably.

• Shipped 3 microservice modules for internal banking platforms in .NET and SQL Server. Hit strict SLA targets
throughout the engagement and kept uptime at 99.9%.
• Refactored and extended internal RESTful APIs, adding input validation and structured logging along the way. Both
changes had a real impact on data integrity and made end-to-end tracing much more useful.
• Mentored two junior developers through the engagement, covering API versioning, layered architecture, and Agile
working practices. Their code quality improved noticeably, and PR review cycles got shorter.

• Built full-stack enterprise applications in .NET Core and React, with PostgreSQL and RabbitMQ powering the
backend. Most of these were high-availability, event-driven systems for large clients.
• Led a codebase modernisation effort that moved tightly-coupled monolithic services into a layered architecture.
Test coverage went from almost nothing to around 40%, using NUnit throughout.
• Ran weekly code reviews and regular 1:1s with three junior developers. Over time, this shaped team-wide coding
standards, shorter review cycles, and fewer defects slipping through to production.

• Built custom desktop and web apps for small business clients using WinForms, ASP.NET, and SQL Server — mostly
replacing manual processes with something that worked reliably and was easy to maintain.
• Handled full client deployments — installation, configuration, and onboarding — and ran IT training sessions to help
clients get comfortable managing things themselves.
• Migrated several legacy VB.NET applications to C#, which cut down runtime and left the codebase in a much better
state for future development.