Denis Mită

I own the primary learner dashboard (eHub), serving ~200k monthly active users within a 2.8M-user EdTech platform.

I also lead frontend development for FIT (Frontier Institute of Technology) — a US-focused university product built on the same architectural foundation.

The system spans multiple frontend surfaces inside a shared monorepo backed by a federated GraphQL backend.

• Contribute to cross-product frontend architecture
• Standardized core UI systems (modals, forms, lifecycle patterns)
• Consolidated shared logic between eHub and FIT
• Contributed to a unified cross-platform navigation SDK
• Leading a Capacitor-based mobile port with native-grade gesture routing

Recently, I've integrated AI coding agents into daily development — increasing delivery velocity while maintaining architectural consistency across surfaces.

Short-term engagement within a global AI and digital transformation consultancy.

I contributed frontend implementations across client projects, including:

• A real-time radio monitoring web application for a Formula E team, focused on performance-aware rendering and streaming message handling.
• Stabilization work on the ALX client dashboard ahead of production release.
• Implemented from scratch an operational dashboard for ALX local hub teams, translating provided designs into a production-ready interface.

Focused on clean API abstraction, rapid onboarding to new codebases, and reliable delivery within consulting timelines.

Stella was an AI-native digital marketing platform built by the team behind Try it On AI.

I contributed as a full-stack engineer during early product development, implementing core web application surfaces and feature flows.

• Built a unified multi-channel social publishing interface powered by LLM integrations
• Integrated Stripe-based billing infrastructure
• Developed custom UI components and product sections across the platform

This engagement required rapid feature delivery within an evolving product environment.

Try It On AI was an AI-native SaaS platform generating studio-quality headshots from everyday photos.

I operated as a senior full-stack engineer within a two-engineer team, working across frontend architecture and backend service layers.

• Refined and reorganized the frontend component architecture to improve maintainability and long-term clarity
• Built multiple image editing widgets from scratch, including standardized resizing pipelines and infinite-scroll lazy loading for large image sets
• Extended backend integrations, handling webhooks, batch upload flows, and model training orchestration
• Designed and implemented an API-key–based public API version of the product, exposing AI capabilities for external integrations

This role reflects full-stack ownership in an AI-driven product, balancing rapid feature delivery with architectural discipline.

Deepwaters was an off-chain trading platform. I created and owned the frontend project from the ground up, implementing the majority of the trading interface and defining its architecture.

I structured the Next.js application, component system, and state management strategy, translating detailed product designs into a maintainable and scalable UI.

Key contributions included:

• Building all core trading widgets from scratch, including data visualizations implemented using raw SVG without external charting libraries
• Designing a deterministic smart amount input that prevented invalid states and ensured seamless formatting without UI flicker
• Delivering full mobile adaptation independently, defining responsive behavior and layout consistency without dedicated mobile design files
• Maintaining the marketing site alongside the core trading dashboard

This role demonstrates full frontend ownership, clean system design, and disciplined 0→1 execution within a well-defined product environment.

At Minerva Gate, I operated as a technical lead within a small product-focused consultancy, delivering client-facing web applications across multiple industries.

• Led frontend architecture and implementation across concurrent client projects
• Defined project structure and technical direction within a lean team environment
• Drove technical alignment between business stakeholders and engineering execution
Let
• Mentored junior developers and enforced quality standards across deliveries

This role sharpened my ability to make architectural decisions under ambiguity, balance client expectations, and ship reliably within tight delivery timelines.

Blink was born from the CS Academy team when our CTO drafted what would become the Blink Protocol — a distributed ledger. In the first phase, we implemented the protocol itself and built the web applications around it.

The product evolved into a unified identity and payments solution for the web. Think Apple Pay, but purpose-built for microtransactions, subscriptions, donations, e-commerce, and email newsletters. Users managed all their web payments from a single dashboard; publishers got a streamlined way to monetize content.

As the founding front-end engineer, I built the landing pages, mobile wallet, user dashboard, publisher dashboard, admin dashboard, and the most technically demanding pieces: the Blink SDK and the iframe application.

The iframe app was by far the hardest challenge — nothing like it existed at the time. I had to navigate cross-browser inconsistencies in how iframes handle clicks, taps, and resizes, and architect a system from scratch.

The SDK, injected into a publisher's website, managed the lifecycle of all iframes on the page (paywalls, banners) while rendering popups in an invisible overlay iframe that covered the viewport without blocking user interactions.

The hardest part was unifying different iframe application types under a single architecture, sharing components between the user dashboard and the embedded apps, and maintaining multiple SDK versions and configurations for different clients simultaneously.

The single most painful feature was cross-iframe authentication. OAuth from inside an iframe is hard enough — browsers limit cross-window communication, APIs change, and popup blockers interfere. Add to that users logging in from the Facebook Messenger in-app browser (single-tab only, redirect-based auth required), and it took real ingenuity to make authentication feel seamless on every browser and device.

Some of the most innovative features lived in the publisher dashboard:

User Journeys — a visual builder that let publishers define conditional logic for user interactions, run A/B tests on each journey variant, and track custom metrics.

Custom Panels — publishers could go beyond styling. They could write custom HTML and CSS, access embedded components and journey variables, and create fully dynamic, brand-specific experiences.

Blink was the most complex product I've worked on, and I'm proud to have architected most of its front-end from day one. You can see it in action on publications like The New Republic and It's a Southern Thing.

Two internships at Google, both during university breaks. The first on the Google Cloud team in Warsaw, Poland; the second on Google Flights in Zurich, Switzerland. Both were front-end focused.

At Google Cloud, I built a standalone Chrome extension for the team — a developer tool for stats monitoring, quick actions, and web inspection. I also contributed a feature to the Kubernetes front-end using Angular.

At Google Flights, I implemented the price evolution chart for tracked flights. While I used Google Charts as the base, matching the design prototypes required creative workarounds — notably using CSS pseudo-elements to render custom tooltip tails that the charting API didn't natively support.

The biggest takeaway from Google was seeing how strong processes enable code to scale. Individual output feels smaller than at a startup, but the system ensures steady, reliable progress. I also learned that at scale, edge cases multiply — at Google Flights, many UI bugs stemmed from right-to-left language support alone.

Building and maintaining products at that scale is a discipline in itself, and team experience is the strongest predictor of success.

I joined CS Academy straight out of high school with zero professional experience. We were a team of competitive programmers who loved algorithmic contests, and we built our own platform from scratch. It's still actively used today for contests, including Romania's national selection camps for international olympiads.

I prepared algorithmic tasks for the platform and built interactive widgets for several of them. The platform later partnered with IEEE to host their annual college-level 24-hour contests, and I served on the contest committee in 2017 and 2021.

Alongside the CTO, I contributed to Stem JS — a custom JSX front-end framework — where I built and styled foundational components: radio groups, tab areas, and a collapsible section divider.

A few standout front-end pieces I built here:

The workspace — a multi-language in-browser code editor built on Ace, wired to a backend for compilation and execution. I parsed build output to display inline errors and warnings directly in the editor.

The graph editor — an interactive visualizer where users can describe a graph via input or draw it manually. We started with D3, then rewrote it from scratch for full control. An essential tool for competitive programmers.

The diff tool — I implemented an O(N*D) diffing algorithm to find string differences, computed the relevant text blocks, highlighted them, and rendered gutter connections using SVG curves.