Working as a Senior Software Engineer embedded within client engineering teams, contributing to product development, architecture, integrations, and delivery across different industries.

Embedded within client engineering teams to deliver production applications across fintech, streaming, AI, commerce, and mobile platforms. Worked with engineers, product managers, and stakeholders on product requirements, architecture, implementation, and delivery.

Developed shared web and mobile marketplace experiences, including product discovery, authentication, and payment integrations.

Built React Native commerce and fulfillment features, including order recommendations, guest checkout, and mobile workflows for order processing.

AgentVault explores a practical problem in AI agent tooling: connecting agents to external services while retaining control over what each agent is allowed to do. It brings provider connections, agent registration, permissions, and tool activity into one interface.

The idea

I built a Next.js dashboard and Fastify API around an MCP gateway. It authenticates MCP clients, discovers available upstream tools, and evaluates access before each invocation. Provider grants, agent capabilities, tool policies, and resource scopes are combined into an effective permission decision, with execution and denial events recorded for review.

Engineering the gateway

The hosted prototype uses a provisioned demo account and a demonstration MCP provider. GitHub and Supabase connector adapters are present in the codebase but are not enabled in the public demo. The repository documents the architecture and setup.

Demo scope

An MCP gateway and permission broker that controls which external tools an AI agent can access, with scoped permissions and an audit trail.

AgentVault

A developer analytics experiment using GitHub OAuth to retrieve pull request diffs and analyze developer contributions over time.

DevMirror

SnapSwap

A voice-first AI learning companion exploring conversational learning, memory, progress tracking, and proactive assistance.

Buddy

A five-minute multiplayer geopolitical negotiation game where players negotiate deals and compete for public support and global influence.

REPUBLIC

I build thoughtful products and reliable systems.

John Ugbe

Over 8 years building and shipping software across web, mobile, fintech, AI, and streaming. I work closely with teams to understand product goals, refine requirements, navigate technical complexity, and deliver software that serves real business needs.

DCP+ is Decentralized Pictures’ streaming platform for films and episodic content. It brings catalogue discovery, rentals, purchases, subscriptions, and advertising-supported viewing into a single experience, with protected playback across web and connected TV.

The familiar act of choosing a title and pressing play crosses several systems: viewer identity, card payments, wallet signing, blockchain settlement, content entitlements, and DRM-protected media. My work connected those boundaries into a usable client application. A successful journey meant that viewers could find content, understand their access, complete a transaction, and watch with progress retained for their next session.

The product

I joined DCP+ through Lazer Technologies in June 2025, embedded within the client’s engineering team. Working alongside product and engineering stakeholders, I helped refine requirements, translate product goals into application behavior, and resolve the integration questions that stood between implementation and a working viewer experience.

From August 2025, I was the primary engineer responsible for the client applications. My scope covered application architecture, feature and integration ownership, technical investigations, connected TV, operational tooling, and release preparation. That responsibility required moving between product details and system behavior: understanding what a viewer needed to accomplish, deciding where the application should own that behavior, and collaborating across service boundaries to make it work.

I carried that approach through catalogue and account experiences, commerce, playback, and episodic viewing. The goal was a coherent product whose parts could evolve together, with maintainable contracts between the interface and the services behind it.

My engagement

I restructured the application around explicit route boundaries to make session responsibilities predictable. Global providers had allowed unrelated dependencies to interact, producing inconsistent request initialization and flashes of content before redirects. Each route needed a clear answer to what session, permissions, and data had to be ready before its experience could proceed.

The resulting structure separated root infrastructure, authentication routes, the main streaming session, and page-local data and permissions. This gave initialization a clearer order and reduced coupling between experiences. Application lifecycle work, including bounded recovery and cleanup, also addressed repeated SDK initialization and made recovery behavior easier to reason about.

Generated OpenAPI types and view models stabilized the interface as API contracts evolved. Generated types exposed contract changes during development, while mapping code kept endpoint-specific shapes out of presentation components. Those boundaries supported discovery, profiles, personal libraries, and series and episode experiences without tying every component directly to a service response.

The Next.js backend-for-frontend provided another deliberate boundary, moving session tokens into HttpOnly cookies with CSRF protection. Together, these decisions made access, data readiness, and lifecycle management explicit responsibilities within the application.

Application architecture

Wallet signing helped establish a viewer session, but continuous wallet connectivity was unnecessary for browsing and playback. When unexpected sign-outs appeared, targeted telemetry showed restoration failures while the wallet SDK was still connecting. I used that evidence to reconsider the dependency instead of simply adding more reconnection attempts.

I made the viewer session the authority for application authentication and treated the wallet as an on-demand signing capability. This separated access to the streaming experience from the availability of a wallet for a particular purchase, subscription, or renewal operation. In-place signing recovery let the viewer address a wallet problem within the transaction workflow.

Commerce required similarly clear boundaries. I implemented Stripe purchasing, wallet-signed transactions, subscriptions, and reusable payment methods, connecting the interface to the steps needed for access. Payment completion, blockchain settlement, and a playable entitlement could arrive separately; showing them as one event produced misleading calls to action and indefinite pending states.

I consolidated five sources of client settlement state into a unified transaction state machine. It gave the application one consistent model of progress, including a longer-than-usual state, while preserving the distinction between paying for content and being able to play it. That made the client workflow clearer and gave technical investigations a more precise starting point.

Commerce and authentication

I integrated DRM-protected playback with FairPlay and Widevine across HLS and DASH delivery, then built the surrounding experience: custom controls, audio and subtitle selection, progress tracking, resume, and playback recovery. The work extended beyond displaying video to maintaining a consistent viewing session across browsers and devices.

Safari exposed a difficult authorization boundary. Protected content played in Chrome, but Safari’s native HLS path did not carry the expected authorization headers. Playlist tokens did not propagate as needed, cross-site cookies were dropped, and alternative playback paths did not resolve FairPlay decryption. Working with the client’s engineering team, I helped establish a functioning path using signed CDN cookies, a CDN alias on the application’s site, and appropriate CORS configuration.

Later compatibility work introduced an iOS 17.1 and newer path using Managed Media Source for authorization injection with FairPlay support. Playback recovery also became a product interaction: Watch Here let a viewer reclaim playback after another session took over.

A shared TypeScript core carried API clients, view models, session logic, streaming behavior, and error handling across web and TV. I built the Samsung Tizen experience around those foundations, with device sign-in and remote navigation adapted to television use. A signed build passed Samsung Seller Office pre-testing in June 2026, establishing a tested distribution path toward store submission.

Playback and connected TV

The engagement produced a live streaming web product and an end-to-end purchase-to-playback journey. A real purchase settled on-chain and became playable in March 2026. Safari DRM playback followed in April, the web service and Cannes beta in May, and a production web release in July. In October, I prepared the v0.3.0 release package, bringing together later work on episodic content, subscriptions, advertising, settlement, and recovery.

Additional contributions made the product easier to operate. I implemented VAST advertising behavior that allowed content to continue when inventory was empty or ad requests failed. Localization automation connected a scoped Laravel import endpoint to CI publishing, using merge-safe updates and translation diagnostics to replace manual resource imports in development and staging.

This work reinforced how much reliable delivery depends on understanding the complete product journey. Clear route responsibilities, explicit transaction state, and evidence-led playback investigations made complex integrations easier to explain and maintain. Being embedded in the team let me connect those technical decisions to product requirements and carry them through implementation, validation, and release preparation.

Delivery and reflection

Engineering a streaming platform across web and connected TV.

Affected cold-start requests in captured local development traces. Not a production-wide metric.

Down from approximately 3–4 seconds in captured local development traces. Not independently verified in production.

DCP+

Concrete is a decentralized finance platform built around on-chain yield vaults. Users deposit supported assets and receive vault shares representing their portion of a vault, giving them access to yield strategies through one interface. The value of those shares changes with the underlying assets and strategy performance.

Concrete’s documented vault model follows ERC-4626, a standard for tokenized vaults. The protocol handles strategy allocation, accounting, and withdrawal operations behind the interface.

I worked across Concrete Earn and Concrete Borrow, with different responsibilities on each product. For Earn, I was the sole frontend engineer, developing the complete application experience in React, Next.js, and TypeScript. My scope covered wallet connection and authentication, vault operations, deposits, withdrawals, rewards, balances, and portfolio experiences.

The work involved direct smart-contract integration alongside supporting APIs. I connected financial data and wallet authorization to the interface so users could review a position, authorize an operation, and follow its result within the application.

On Borrow, I worked alongside another engineer, contributing to multi-network vault management, liquidation protection, APY visibility, and reusable SDK integrations. This combined full application responsibility on Earn with focused contributions within Borrow’s shared implementation.

I built the Earn client from wallet connection and authentication through vault transactions, rewards, balances, and portfolio management. The application connected the information users needed to assess a vault with the operations needed to deposit, withdraw, and review their holdings.

I integrated on-chain reads, wallet signing, and transaction execution directly with smart contracts and supporting APIs. The client had to connect financial operations to understandable actions: reading a position supplied information, while changing it required a user-authorized transaction. My work joined those different interactions into the vault workflow.

Alongside another engineer, I contributed to multi-network vault management, liquidation protection features, and APY visibility. I also developed reusable SDK modules for partner integrations, extending those capabilities beyond a single application surface.

Engineering work

My work delivered the Earn client experience and targeted contributions to Borrow. The engagement reinforced the importance of making financial information and transaction authorization understandable together, with clear boundaries between what the client displayed and what users signed.

Engineering DeFi products around wallet identity, smart contracts, and financial workflows.

User-reported platform scale; not value personally generated by John. No reporting date supplied.

Owned the complete Concrete Earn client, from wallet identity to smart-contract transactions and portfolio views; contributed to Concrete Borrow.

Concrete Finance

Reka’s 2023 research application let users supply their own data to fine-tune models, then explore the results through streaming conversations. It connected model customization with a practical way to examine a model’s responses.

Beginning in March 2023, I worked as the sole client-side engineer on a greenfield AI research application. I built the client from scratch, covering assigned-token access, model fine-tuning workflows, and streaming conversations. The scope connected the user’s first access to the application with their later interaction with a customized model.

I integrated Python APIs that exposed the fine-tuning capabilities, building the user-facing path for supplying data and using the resulting models in chat. The backend services handled training and inference; my responsibility was the application through which users accessed those capabilities.

The conversational experience completed that workflow. I worked on progressive responses and conversation handling so model customization led into an ongoing exchange within the same application, rather than a disconnected set of research features.

I established the client application and integrated assigned-token access. I connected that access model to the research workflows, keeping client actions aligned with the operations supported by the backend contracts.

I integrated Python APIs that let users supply their own data for model customization. The client connected data submission and fine-tuning interactions with the resulting model’s conversational experience. This work concerned access to the training services, not implementation of the models or training infrastructure.

I built the chat interface to display responses progressively as they arrived while maintaining the ongoing conversation. This completed the customization journey by letting users interact with their fine-tuned models in the same application.

The application brought token-based access, model customization, and streaming conversations together. Building it strengthened my approach to greenfield engineering: define the client’s responsibilities around the user journey and validate those responsibilities against the capabilities of the underlying services.

Building a greenfield AI research application for model fine-tuning and streaming conversations.

Sole client-side engineer for a greenfield AI research app, integrating model fine-tuning through Python APIs and streaming conversations.

Reka AI

React Native work on app lifecycle, iOS location and motion permissions, trip tracking, and dashboard synchronization.

John Ugbe

// selected work

DCP+

Concrete Finance

Reka AI

Cardata

// experience

Senior Software Engineer @ Lazer Technologies

Senior Software Engineer @ Global Villages

Software Engineer @ Mart

// about

John Ugbe

// selected work

DCP+ ↗

Concrete Finance ↗

Reka AI ↗

Cardata ↗

// experience

Senior Software Engineer @ Lazer Technologies

Senior Software Engineer @ Global Villages

Software Engineer @ Mart

// about

DCP+

Concrete Finance

Reka AI

Cardata