Tayler RamsayFull-stack design engineerOpen to 2026 work

I design products,
then I build products.

Twenty years of visual and interaction craft, and twelve of writing the production code underneath it, from the TypeScript in the browser to the Kotlin, Node and Python services and the PostgreSQL behind them. Most of what I make now is AI-native and developer-facing: interfaces for systems that stream, cite their sources, and are sometimes wrong.

20
Years of craft
12
Years shipping JS / TS
3
Years orchestrating agents

Most designers stop at handoff.Most engineers never read the research.

I do both halves, on the same project, for the same team, which means the design is shaped by what the technology can actually do, and the thing that ships still has the intent in it.

I started in print and identity work with a B.A. in Visual Communications, and I have been writing production JavaScript for twelve years. That order matters: the typography and the colour judgement came first, and the engineering arrived to serve it.

At Versatile Credit, now part of Synchrony, I own the interaction design, the visual design, and the TypeScript, Vue and Tailwind that ships, along with the PostgreSQL models and Kotlin APIs behind it. Three very different audiences read the same platform, so the design system has to hold consumer, merchant and internal operator without any of them feeling like an afterthought.

For about three years my practice has been agent-orchestrated: research the current pattern, write the failing test, direct the agent at it, and keep the tree working at every commit. Agents make the throughput. The taste and the verification are mine, and that division is the whole point.

Most of what I design now is AI-native and developer-facing, which is a specific design problem rather than a general one. The system streams instead of resolving. It is confidently wrong sometimes. The interface has to make that legible: citations you can open, a verdict before the evidence, a threshold where the honest move is to ask rather than answer.

Tayler Ramsay
Tayler Ramsay. York County, Pennsylvania. Remote, with a passport and no objection to using it.

The record

Senior Product Designer and Engineer
Versatile Credit / Synchrony Bank · 2019 to now
Design and build the platform's product surfaces: consumer application flows, the merchant operator console, and the internal tooling Versatile onboards merchants with. 12% completion lift across 6M applications a year. The design system underneath it, 85+ form templates and a four-level cascading configuration UI, is used by three product teams.
Consulting Product Designer
Rayni and independent clients · 2024 to now
Three products taken from nothing to production: Rayni, an AI document platform in daily use at scientific research labs; Document Domain Agents, the retrieval framework extracted from it; and Goldlink, a WebRTC telehealth platform built for elderly patients.
Independent product work
PadLab, Breakpoint, Qualified, MindPattern · 2023 to now
Products where I am the only designer, the only engineer, and the person who decides when it is good enough. This is where the craft gets tested without a committee to hide behind.
Designer, then designer who writes code
Pavone, Glatfelter, Menasha, Quad/Graphics · 2010 to 2019
Brand and identity systems, illustration and art direction, client web applications, and a multilingual intranet portal. The visual training that everything since is built on.

What I work in

The tools change per project. The constant is one person carrying the research, the design, the front end, and the services and schema underneath it.

Design

  • Visual and interaction design
  • Design systems and tokens
  • Figma, low fidelity to build-ready
  • Component API design
  • Typography, colour, elevation
  • Motion and micro-interaction
  • Illustration and art direction
  • Accessibility (WCAG)

Three design systems in production across the Versatile platform: consumer, operator, and internal.

Front end

  • TypeScript
  • React / Next.js
  • Vue
  • CSS / Tailwind
  • Three.js and WebGL
  • GSAP, Web Audio, WebRTC
  • Storybook
  • Progressive and offline-first web apps

I ship the code for the flows I design. 12% conversion lift on 6M annual applications.

Back end

  • Kotlin / Spring Boot
  • Node.js
  • Python / Django / FastAPI
  • REST API design
  • PostgreSQL and schema design
  • pgvector, Neo4j, Redis
  • Docker, Cloud Run, Fly.io
  • Flyway migrations

At Versatile I design the PostgreSQL models and write the Kotlin APIs under my own interfaces: 120+ endpoints, 49+ migrations.

AI

  • LangGraph agent workflows
  • RAG on pgvector and Neo4j
  • Model Context Protocol
  • Streaming and tool-calling interfaces
  • Generative UI in chat
  • Trust, citation and verification UX
  • Agent-orchestrated development
  • Spec-driven, test-first delivery

Two retrieval architectures in production, and three AI products taken 0-to-1 in the past two years.

Selected work

Fintech at scale, AI in production, and things I built alone because I wanted to find out whether I could. Every number below is one I can show you the source of.

Versatile Credit · part of Synchrony (NYSE: SYF)

Versatile Credit

One platform, three product surfaces, three audiences. Lead designer across all of them.

Versatile Credit is the consumer-financing platform behind $16B+ in financing annually, 6 million applications a year, and 13,000+ retail locations, acquired by Synchrony in 2025. I design and build across all three of its surfaces: the consumer-facing applications, the merchant operator console, and the internal tool Versatile uses to onboard new merchants. Three different audiences, three different design languages, one person across all of them.

01 / 03

Versatile Apply

Consumer financing across 4 channels and 35+ lenders.

FintechMulti-tenantDesign Systems
+157%

Near-prime approvals across Versatile merchants with high platform adoption. 6M annual applications. 3-min decision.

A consumer applies for financing once. The merchant wants that one application to reach 35+ lenders without 35 forms, 35 redirects, or 35 different compliance gauntlets. Every lender has its own gateway, fields, and regulatory language. The platform absorbs all of it with one application contract that themes per merchant and per lender. Compliance text becomes a design-system token, not content.

6M
Annual applications across 4 channels and 35+ lender integrations
+92% / +157%
Prime applicants and near-prime approvals on Versatile merchants with high platform adoption
3 min
Time-to-decision vs 10–15 min traditional
02 / 03

Versatile Transact + Analytics

Operator console and analytics surface. Themed per merchant, scoped per role.

Operator ToolMulti-tenantAnalytics
$43M+ / 7 days

Financing managed in a single 7-day window on one elective medical partner's dashboard. 16,500+ payments processed in the same window.

Apply is the surface a consumer sees once. Transact is the surface the merchant lives in. Three jobs on one console: Launch sends an application to a customer's device by QR, email, or Snap Sign; Track exposes the lender cascade per application with full audit log; Analytics surfaces 40+ metrics across 20 facets (approvals by age, by income band, by location, by lender). Same product themed across every merchant on the platform. Multi-tenant is not a CSS layer here. Each merchant's brand color is a token, each merchant's enabled lenders are a config, each location's role permissions scope what staff can see and do. Theming is a design system, not a stylesheet.

$43M+ / 7 days
16,500+ payments processed in a single window, one elective medical partner
40+ metrics
across 20 facets in Versatile Analytics
13,000+ locations
Brick-and-mortar retail running on the platform
03 / 03

OnboardIQ

Merchant onboarding workflow product. 0-to-1 at Versatile / Synchrony.

Workflow ProductFintech0-to-1
5 days → 2 hours

500 locations onboarded in a single session for an elective medical practice program.

Merchant onboarding ate a full cross-functional team. Five days of meetings per partner to gather configurations from sales, ops, risk, and the partner themselves. Six entity types, each with about ten metadata fields, arrived through email and Slack threads. Tickets dropped, configs drifted, and stakeholders had no visibility into program status without booking a meeting. I designed OnboardIQ from a blank canvas: a flexible workflow product that codified the entire process into configurable, partner-aware steps. Audits and automation went directly into the workflow, so validation, status, and handoffs were surfaced inline instead of chased over Slack.

Tasks.Single inbox cuts across every running deployment. 107 active, 32 done, 22 in flight, 40 overdue. The same view that replaced the weekly coordination meeting with a 5-minute daily brief.
30,000+
Merchants onboarded
3
Verticals (retail, elective medical, home improvement)
3 days → 3 hours
Support ticket resolution
Consulting · outside of Versatile

Consulting work

Designing for systems that stream, cite their sources, and are sometimes wrong.

01 / 02

Rayni

AI document intelligence platform. In daily production at scientific research labs.

AI / RAGIn Production0-to-1
Split-screen

Every answer sits beside the page it came from. Citations deep-link to exact coordinates in the source PDF, so verifying a claim is one click, not a search.

I designed and built both halves of Rayni: the product, and the marketing site at rayni.ai that sells it. Lab technicians could not trust AI answers without seeing the source documents, and the tools they had gave answers with no way to check them. I designed the verification interface: the response on one side, the actual page on the other, and citations that jump to the exact coordinates they came from. The gap-detection pattern uses an 85% confidence floor, below it, the system asks for the missing document instead of guessing. That pattern was later extracted into Document Domain Agents. The design system underneath carries hierarchy through color layering and elevation rather than border lines, and is documented in Storybook.

www.rayni.ai
The marketing site, live and scrollable here. I designed and built it: the positioning, the type, the layout, the product shots, and the front end. The screen inside its hero is the real answer surface, mid-run, showing its work as it searches the documents.Open rayni.ai
Same site, phone width. Also live.Open rayni.ai
What I did
Designed and built the marketing site, and designed the product it sells
Who it is for
Lab technicians and field service engineers who have to operate an instrument correctly the first time
The design problem
Not retrieval. Designing for a system that is confidently wrong sometimes, so every claim has to be checkable
Trust surface
Split-screen verification, streaming responses, and citations that deep-link to exact coordinates in the source PDF
The honest answer
Below an 85% confidence floor the product asks for the missing document instead of guessing
Design system
50+ components in Storybook, carrying hierarchy through colour layering and elevation instead of border lines
Workspace.Single workspace replaces six separate routes with one mode-aware shell. Three primary actions on the welcome surface: chat, knowledge, combinations.
Mockups · pre-build
Chat.Reasoning + streaming text + inline citations + sources badge. The four primitives that anchor every Rayni response, designed before a single line of production UI was written.
50+
Design-system components, documented in Storybook
85%
Confidence floor, below it the system asks instead of answering
Daily use
Running in production with lab technicians and researchers
02 / 02

Document Domain Agents

Domain-agnostic, high-stakes RAG framework. Extracted from Rayni.

AI FrameworkTrust UX
85%

confidence threshold for the "never guess" gating policy.

Most RAG systems guess when they don't have enough information, which creates dangerous false confidence in safety-critical contexts. Document Domain Agents is the framework I extracted from Rayni for any domain where AI accuracy is non-negotiable. The gap-detection UX turns AI limitations into collaborative moments. When the system needs more, users upload the missing documents instead of losing trust in it. Verification is split-screen, BLUF formatting handles scannability, and confidence indicators are calibrated to domain risk.

Items, empty.The item list before anything is ingested. The empty state names what to do next rather than showing a decorative illustration.
Mockups · pre-build
Empty.Cold-start chat. Sidebar lists items, knowledge folders, and admin. No inferred questions, no demo prompts. The agent waits for a real query before doing anything.
11 nodes
LangGraph stateful agent workflow with checkpointing
3 layers
Vector search, graph augmentation, cross-encoder reranking
BLUF
Verdict, evidence, fix, and safety warnings in every response
Independent · sole designer and engineer

Things I built alone

No committee, no handoff, nobody else to blame for the kerning.

These are the projects where the craft gets tested without cover. I made every call in them, the product, the type, the motion, the architecture, and the decision about when it was actually finished. Two of them you can use right here on this page.

01 / 05

PadLab

A sampler, beat maker and voice lab for iPhone. Designed once, built twice, native Swift and a zero-dependency PWA.

AudioiOS + PWALatencyOffline-first
18.4 ms

Median trigger latency over 200 real triggers, measured at the audio graph rather than at the CSS class. p95 18.5 ms, worst 18.6 ms, reproducible to a tenth of a millisecond.

Tap a pad, hear it instantly. Record your voice and turn it into a monster, a robot or a telephone. Chop a sample, build a beat on the step sequencer, export the result. Everything works offline, nothing is uploaded, and there is no account. One rule shaped every design decision in it: a touch reaches the audio engine before anything else happens, not quickly, first. That rule is why the iOS pad grid is a UIKit multi-touch surface instead of a SwiftUI gesture, and why the web build has no framework at all. The two implementations share a project format, so a backup written on the phone opens in the browser and back again. Where the platforms genuinely differ, background audio, haptics, crash recovery of a take, codec support, the gap is written down and the fallback is named, rather than papered over.

PadLab board: a 4x4 pad grid mid-performance with one pad lit and playing
PadLab / Board. Installable to the Home Screen.Open PadLab

The pad grid, mid-performance. Grid size, bank switching, stereo meters and a panic stop all sit above the pads, because during a take you need them without hunting.

Web build
TypeScript, no framework, no runtime dependencies
iOS build
Swift + SwiftUI, UIKit where touch latency demanded it
Storage
IndexedDB for structure, OPFS for audio; nothing uploaded
Measured
18.4 ms median trigger latency, p95 18.5 ms
0
Runtime dependencies in the web build; Apple frameworks only on iOS
32 voices
Preallocated, with per-pad strips and a master peak limiter
Two builds
Swift + SwiftUI and TypeScript PWA, one shared project format
02 / 05

Breakpoint

A 3D brick breaker in Three.js, art-directed as ink and paint on paper. A portfolio you play instead of read.

Three.js / WebGLMotionRuntime audioArt direction
No audio files

Every sound in the game, the hits, the power-ups, the jackpot bell, the adaptive music bed, is synthesised at runtime. There is not a single sample in the project.

Black ink blobs sit on a warm paper court, an ink-drop ball splatters them, and the stains stay where they land. The murals on the walls are hand-made. Levels come out of a seeded procedural generator, so a pattern has a name and can be reproduced. The architecture is deliberately one-directional: the game module knows nothing about the DOM and reports what happened through a plain callback object, so the HUD, the screens and the audio engine are all downstream of one event contract. The only runtime dependency is Three.js; everything else is hand-rolled. It doubles as a portfolio surface, the title screen and the work drawer are part of the app rather than bolted onto it.

Tablet, landscape. Mouse or trackpad moves the paddle, space smashes, P pauses.Play it
Phone, portrait. The court reflows to the taller screen.Play it
Renderer
Three.js, the only runtime dependency in the project
Audio
Synthesised at runtime; no sample files anywhere
Levels
A seeded procedural generator, so a pattern has a name
Art
Hand-made ink murals; splatter stains where it lands
Architecture
The game knows nothing about the DOM and reports through one event contract
7
Power-ups, each with its own presentation rules
1
Runtime dependency, three
Seeded
Procedural brick patterns, reproducible by name
03 / 05

Qualified

An AI financing sidecar. A Chrome side-panel extension that surfaces multi-lender financing while you shop, with interactive UI rendered inline in chat.

Chrome ExtensionMCP AppsGenerative UI
5-lender waterfall · in chat

Synchrony (prime), Fortiva (near-prime), Acima (lease-to-own), Affirm and Klarna BNPL. Every customer qualifies for something.

Qualified lives in the browser side panel while you shop. Tell it what you want, say, a laptop under $1,000, and it searches products, compares them side by side, and surfaces real financing options the moment intent shows rather than at checkout. The wedge is MCP Apps, where a tool returns an interactive HTML interface instead of just text: sandboxed iframes hydrate over postMessage to render comparison tables, payment calculators, product grids and pre-filled application forms directly inside the conversation. The same multi-lender waterfall pattern as Versatile, reimagined as an agentic sidecar with generative UI.

Welcome.Side panel docks beside any retail site. No checkout integration required. Qualified rides along while you shop and asks what you are looking for.
8 tools
Agent decides the flow; 7 return interactive UI
5 lenders
Prime through BNPL
Sidecar
Sits next to any retail site, no checkout integration required
04 / 05

MindPattern

An autonomous AI research pipeline, and the public reading surface it publishes to. Personal infrastructure I run every day.

Agentic SystemsMCP Generative UIEditorial
13 agents · daily

A Python pipeline runs itself every morning: gathers from eight sources, dispatches thirteen specialist research agents in parallel, synthesises a newsletter, and posts it.

MindPattern is two systems wired together. The backend is a deterministic twelve-phase Python pipeline that operates as a one-person media company on autopilot: preflight collection across RSS, Hacker News, arXiv, GitHub, Reddit and more; parallel dispatch of thirteen specialist research agents; synthesis; publishing; and platform-native social posting. A self-improving harness finds bugs in the pipeline, writes fixes test-first, reviews its own pull requests, and merges them. The public site is the other half: a reading surface and a chat interface built around generative UI, where a tool call renders React components inside the conversation, finding cards, source tables, health dashboards, instead of a wall of text. It is dressed as an intelligence dossier: monospace throughout, a manila palette, stamped badges and grid-paper texture.

The public reading surface, live. What it is showing was gathered, researched and written by the pipeline this morning.Open mindpattern.ai
The pipeline
A twelve-phase Python run: collect across eight sources, dispatch thirteen research agents in parallel, synthesise, publish, post.
The harness
A second loop that finds bugs in the first one, writes the fix test-first, reviews its own pull request, and merges it.
The surface
Next.js. A tool call returns React components rendered inside the conversation: finding cards, source tables, health dashboards. Not text describing data.
The dressing
An intelligence-dossier aesthetic: monospace throughout, manila palette, stamped badges, grid-paper texture.
12 phases
Fully autonomous daily run across 8 sources
20,000+
Findings indexed and connected in the public graph
Self-merging
Test-first agents write, review and ship their own PRs
05 / 05

Local Video Studio

A native macOS front end for open-weight AI video generation that never leaves the machine. In development.

macOS / SwiftUILocal AIMedia ToolingIn development
Nothing leaves

Prompts, reference media, model weights and generated video all stay on the user's Mac. No account, no upload, no inference API.

The workflow is still-first and shot-based: generate a master still, optionally derive reference-preserving keyframes, produce short image-to-video candidate takes, select one take per shot, then assemble hard cuts locally. The interesting design problem is honesty about time and quality. Local generation on Apple silicon takes minutes, not seconds, so the interface shows elapsed time next to a measured baseline from a real run and a clearly labelled estimate, never a fake progress bar. Generated stills carry AI disclosure and hashes-only provenance, and the exporter says it makes hard cuts rather than claiming seamless continuation. Where a model route has not been visually qualified, the app says so instead of implying it is ready.

Local only
Open-weight models running on-device via Apple silicon
Shot-based
Multiple candidate takes per shot, one explicit selection
Provenance
AI disclosure and hashes recorded on every generated still

Much of the Versatile work is behind a login and cannot be shown publicly. Email me and I will walk you through it, screen recordings, the codebase, or a live ticket together.

ramsay.tayler@gmail.com

The shortest path is email.

I read every message. The fastest way in is a paragraph about what you are working on and what is currently in the way of it.

Direct

GitHub
tayler-id

Based in York County, Pennsylvania. Remote only, and happy to travel for the parts of the work that are better in a room.

Or write here