The Assembly Line
Eight years on the line. Angular taught structure, Vue taught speed, React taught composition — the frameworks changed, the way of thinking about them compounded. All of it self-taught, in my own time. No syllabus, just whatever the next problem needed. Expand a station to see what came off each one.
A portfolio built as its own argument: a scroll-driven 3D machine that takes itself apart. Every layer — model, animation, audio, and page architecture — is hand-built rather than assembled from templates.
Modeled the machine in Blender from scratch — the outer shell, the internals, and every part that has to come apart on camera.
Rigged it with roughly 700 bones so each component can hinge, slide, and separate independently through the teardown.
Animated the full disassembly and reassembly, then rendered the result to the 170-frame sequence the site plays back.
This is the foundation the whole site is built on: the scroll pipeline, the audio cues, and the copy timing are all keyed to frames that came out of this rig.
Scroll position selects the current frame from the 170-frame WebP sequence and swaps it onto a single full-screen mesh, so the entire animation costs one draw call.
Frames preload behind a loading gate before the experience opens, keeping 8 MB of textures off the critical render path.
The canvas is dynamically imported with ssr disabled, since react-three-fiber needs window and WebGL at mount.
Canvas and text overlays never reference each other: the scroll loop emits active section ids on a typed singleton event bus, and each text block subscribes and animates itself.
Copy, timing, and placement live in one config array keyed by scroll percentage, so adding or retiming a section touches no component.
Same bus carries loading progress, scroll progress, and scene status to the HUD.
Hand-rolled wrapper over a single AudioContext, spawning a buffer source per play so cues layer instead of cutting each other off.
Per-sound cooldowns and a maxDuration fade-out stop fast scrolling from machine-gunning the same sample.
Unlocks on the first pointerdown, scroll, or keydown to satisfy the Safari and iOS autoplay policy.
Particle field drawn as one points call, with motion and lifecycle derived from a time uniform in a custom vertex shader — nothing is uploaded per frame.
Perspective attenuation is guarded and clamped at the camera plane, so particles drifting past the viewer never flash to full screen.
Designed on the fly rather than upfront — a scroll-driven 3D piece cannot be judged as a static mockup, so layout, type, and palette were iterated in Claude Design against the running build.
Styling implemented with Tailwind v4, whose theme layer carries the whole system as tokens: six named colors, three type families.
Custom keyframes and a shared content utility keep motion and spacing consistent across pages without per-component overrides.
Metadata API driven from one shared title and description — metadataBase, canonical alternates, and OpenGraph plus Twitter card tags.
OG image generated at request time with next/og rather than shipped as a static asset, so link previews never drift from the design.
Robots, sitemap, manifest, and icon all authored as code rather than dropped in as files.
Semantic document shell: lang, a main landmark, and themeColor plus colorScheme so browser chrome matches the page.
Four and a half years, most of it on HP's internal sales tooling, remote across several teams. This is where I learned how software gets made at enterprise scale — slowly and deliberately, through many layers and many people, every change moving from user story to change request to a full CR approval pipeline in Azure DevOps. After years of being most of the machine myself, here I was one small part of a very large one — and that is where I understood why the pace produces software you can trust.
Built the initial POC for embedding React (PCF) components inside Microsoft Dynamics CRM — an approach the Microsoft team first rejected in favor of Power BI. After a live demo the business chose React, and the project shipped and is still in production.
Grew from one application to three (3-4 modules each), each with its own infrastructure, bringing data collected from external systems into a single interface inside CRM instead of a set of separate standalone tools.
Owned UI architecture and analytics — Azure Application Insights event tracking across all three applications.
Performance work came down to how much data crossed the wire and how often — large sets paged in on scroll instead of up front, single heavy requests split into several smaller ones running in parallel, queries narrowed to the window actually in view (a week or a month rather than everything), and results held in a Zustand store so returning to a tab did not refetch what was already there.
Built the interface against mock data first, and the real API was often written afterwards to match it — structure, volume, and types settled directly with the backend and database developers, so the UI defined the data contract instead of adapting to one.
Maintained detailed technical documentation for every code change, keeping the work transparent and transferable across teams.
Worked with several cross-functional teams, and the platform ended up in day-to-day use across HP's sales organization.
Primary developer on HP's sales console — accounts, sales planning, and step-by-step workflows spanning the full hierarchy from territory down to opportunity level.
Made the architectural decisions and defined how new functionality got implemented, and was the person the rest of the team came to when they were unsure.
Built the heavy UI — dashboards with multiple charts, and large data tables with filtering and sorting.
Owned the form layer end to end, rewriting and recomposing forms that ran past 200 inputs. At that scale a form stops being markup and becomes an architecture problem: how it decomposes decides whether validation, state, and render cost stay manageable.
Improved performance by changing what the app fetched and when — deferring data that was not needed yet and recomposing the request flow, so screens stopped blocking on calls they had no reason to wait for.
Wrote the unit tests for the front end — component tests plus store logic exercised against mocked Vuex state — and ran the knowledge transfer that brought the rest of the team up on testing Vue.
Instrumented the product with Azure Application Insights, tracking specific events so the team could see how the console was actually being used rather than assuming.
Built as an MVP by one team first, then taken to production with a larger team and a completely replaced backend — I realigned the entire front end to the new API, reworking the integration layer and remapping every request and data model.
Maintained and evolved the product across roughly 15 production releases, from post-launch stabilization through to its decommissioning a few years later — one product carried across its entire lifecycle, start to finish.
Joined mid-flight and built out several modules of a personnel hierarchy tool spanning global region down to organization level, the complex multi-step forms among them.
Arrived with the deadline close and the product not ready to ship — worked through the tickets standing between it and production until it could go.
Conducted technical interviews for senior Vue.js developer roles as the team expanded.
The one non-HP project in those years, and support work rather than a build — periodic interface updates, bug fixes, and new pages and stations added to an existing statically generated Next.js site.
Resolved server-rendering and static-generation build errors as they surfaced.
Fixed a long run of broken and missing ad banners — revenue bugs rather than cosmetic ones, and third-party ad scripts fail quietly in ways the rest of a page does not.
Nine months and four products, and the point where the work turned outward — dealing directly with clients and product owners, in English, for the first time. Vue 3 started here, and so did real-time video.
An MVP already existed, but a new design meant starting over — I rebuilt the whole application from zero, and the rebuild carried far more than the original did.
Built the call surface in Vue 2 over WebRTC: camera, microphone, and screen sharing, live in the browser.
Two conference modes — an open one where everyone participates equally, and a hosted one where only the creator can show camera or share screen.
Host controls throughout: new participants wait to be admitted, and the host can mute or remove anyone mid-call.
Real-time chat over WebSockets running alongside the call.
Worked through a long backlog of open tickets, most of them Safari-specific — WebRTC diverges from Chromium there, and every difference had to be tracked down and worked around.
The first time I made a browser do something I did not think a browser could do.
Built two CRM-style back offices for the video conferencing product — one over users, chats, invitations, and messages, the other a marketplace-style catalogue of products.
The administrative layer over the same domain the calls ran in: the accounts, conversations, and invitations the live app was generating.
Worked directly with the client's own designers, managers, and backend developers, taking requirements, design handoff, and API contracts first-hand.
Built the CRM itself: dashboards of charts and dense data tables throughout the app.
Built the reporting layer — a large set of reports, each downloadable as a generated PDF.
Joined a substantial existing codebase and built the grading module inside it, following the structure and patterns the team had already established rather than importing my own.
My first Vue 3 work — learning the version by building in a codebase already written in it.
Worked directly with the product owner and their backend developer.
The first project I ran entirely in English, and the start of working internationally, which is how I have worked since.
The most intense stretch of my career. Five very different products in nineteen months — an SVG editor, a pair of offline PWAs, a healthcare platform, a trading UI, and animated marketing sites — most of them demanding a technology I had not used before. Frequently over my head, and the fastest I have ever grown as a front-end developer.
Built the map search on Leaflet and OpenStreetMap, plotting medical facilities, doctors, and diagnostic technologies, with appointment booking on top of it.
Four user types — patient, doctor, clinic, and technology provider — each with its own interface, all served from a single Angular 6 codebase.
Built the interface motion with Angular Animations, using the framework's declarative trigger and transition API rather than hand-written CSS keyframes.
Data flow managed with NgRx, which kept four interfaces sharing the same underlying entities predictable instead of tangled.
Server-rendered through Angular Universal, so a directory people reach through search stayed crawlable and fast on first paint.
Built an SVG editor for customizing prints on apparel and accessories — T-shirts, mugs, caps — and still the hardest thing I have written.
My first Vue application on top of that, so the difficulty ran on two tracks at once — working out the editor's logic while learning the framework I was expressing it in.
Wrote the geometry layer by hand: vector transforms driving rotation, scaling, and layer ordering.
Everything the user assembled was serialized back to the backend as SVG and sent straight to print — the file leaving the browser became the physical product delivered to them, so the geometry had to be exact.
Built two offline-first applications: a point-of-sale app holding products and receipts, and a companion app for personnel management.
The full product catalogue loads into IndexedDB when a shift opens, so the till keeps working with no connection at all.
Receipts are created against that local data through the shift, queued in IndexedDB, and pushed to the server whenever a connection is available, with a retry loop that keeps working through anything still pending.
Those receipts had to reach the tax service, so the sync layer could not quietly drop one — an unsent receipt was a compliance problem, not a UI inconvenience.
Printed customer receipts from a template, with laser barcode scanner integration for adding products at the till.
Built the entire interface in vanilla JS with no framework: a Chart.js price chart for BTC and ETH updating in real time, with the user's open orders plotted on the same axes.
Connected to the backend over WebSockets, so price movement and order fills arrived as they happened instead of on a poll.
Implemented the order-placement strategies that decided where orders sat relative to the current price — fixed-step grids and Fibonacci-spaced levels.
The interface was the visualization layer over real money: orders drawn here synced to the backend, which placed them on the live exchange.
When an order filled, the chart reconciled in the same update — the closed order dropped off and its replacement opened, so what the trader saw always matched the exchange.
Built 5-10 landing pages, implemented pixel-perfect from Figma mockups.
Added GSAP animation to several of them — motion treated as part of the design rather than decoration applied at the end.
Ported some onto WordPress so clients could manage their own content without a developer.
First real job in IT, at an IoT software company, and where writing code turned into engineering — Git and branching, estimating work before starting it, and the realization that a meeting is part of the job rather than an interruption to it. This is where I learned how software gets built by a team instead of by one person.
My first project as a developer — joined near the end rather than starting it, inheriting a codebase someone else had built.
The work was reading before writing: getting deep enough into unfamiliar AngularJS to extend it without breaking what already worked.
Contributed to the buy-and-sell flow, contract generation, and status tracking as a deal moved through its stages.
Worked on the admin panel behind it too, used to manage the site's content.
Multilingual with right-to-left support, so every layout change had to hold up mirrored as well as normal.
Built all three parts of a law firm's platform: the public site its clients use, an admin panel for managing that site's content, and a CRM the firm's own lawyers work in.
Three audiences, three different kinds of interface — a public surface that had to persuade, an editing tool that had to be hard to break, and an internal system that had to stay fast for people living in it all day.
Shipped multilingual, with Hebrew among the languages — so the interface had to mirror for right-to-left reading rather than just swap strings: alignment, layout flow, and component direction all flipped.
The first product I took end to end rather than inherited.
Built a Node.js client and server pair that send and receive packets in real time over whichever protocol is selected — MQTT, MQTT-SN, WebSockets, CoAP, or AMQP.
Server exposed a REST API to the web interface, with Redis holding connection and message state and RabbitMQ moving messages between the app's own internal components.
AngularJS web interface on top for picking the protocol, opening and closing connections, and watching traffic move in both directions live.
Each protocol carries its own transport and message model, so the client presented them through one interface the UI could drive without knowing which was active.
Built and maintained few sites — the company's own, plus product and service sites across its IoT lines.
Each one shipped with its own admin panel for managing content, so every build was a front end and a back office rather than a brochure.
The volume work, and where layout, cross-browser quirks, and handover stopped being obstacles and became routine.