Founding Frontend Engineer

In-person (3 days/week minimum) · $160-220K base + 0.03–0.05% equity

Shade is scaling, fast. In a year and a half, we’ve built out the combined tech of Frame.io (acquired by Adobe for $1.275B) and LucidLink ($40M ARR) while combining it with proprietary AI search and labeling. We’re a critical piece of infrastructure for post-production houses, creative agencies, sports teams, and internal media teams at large companies.

Customers include Salesforce, Snowflake, A24, the Boston Celtics, Hello Fresh, Deloitte, and Motorola. We’re already ingesting 20-30% of Dropbox’s daily data: 50TB a day, 10M minutes of video a month, hundreds of millions of assets. We’re growing 200% QoQ with 120% NRR.

We also just closed a $14M Series A, backed by Khosla, General Catalyst, Construct Capital, Contrary, SignalFire, and Bling.

How we think about Shade:

• The interface is the product. Customers live in Shade eight hours a day, which is why our fourth hire was a designer, not an engineer. This hire is the engineering half of that same bet.

• Storage layers don’t talk to other tools. Files move between project management tools, AI tools, ad generators, MCP servers, and Premiere panels. Someone has to store them, reconcile versions, and integrate with everything. Most of that shows up in the frontend.

• Version control wasn’t built for creatives. Git history is useful for engineers; the same concepts are useful for media teams. We’ve built the backend (every version of every file saved as a commit) but the creative UI isn’t there yet.

• Data transfer is unsolved. From hot storage → archive storage, cloud → cloud, camera → editor, moving high volumes of data is still flaky, unreliable, and difficult. We’re building the tooling and UI directly into the platform.

Two years ago we wrote the Shade desktop app on Electron in the time it took to win a hackathon. The backend had to be right, so we put our weight there, and we kept shipping features on top of it. We built a streamable file system in C++, integrated at the kernel level (one layer deeper than where Google Drive or Dropbox sit), and got it to 99.99999% reliability across distributed state on every machine. Today we move 50TB of data a day and serve customers who treat Shade as their system of record.

But the frontend didn’t keep up. The types are off, the design system is half-built, the component library has six versions of a button. It works; customers ship feature films and championship campaigns on top of it. It just isn’t built for what we’re shipping next.

Some of this is unusual work. Making remote 4K video files render, scrub, and play back instantly through a Chromium renderer talking to a kernel-level mount via IPC. Building Premiere panels that talk to our auth system and the mount so editors can search Shade and pull subclips into their timeline without leaving the app. Hitting performance budgets in a Chromium renderer competing for memory with Premiere and DaVinci Resolve on the same machine. These aren’t problems most web-first frontend engineers have faced before.

The rest of the work is foundation. The design system, state architecture, component library, and file organization are all unfinished, and all would be yours. Mobile fits in here too: we have an app now, and we’re moving toward a unified monorepo with shared types across web, desktop, and mobile. You’d shape that.

Then there’s the production surface. The IPC between the renderer and the ShadeFS process running in the background. The auto-updater that has to ship a fix today without breaking the customers still on version 2.14. The code-signing certificates that decide whether anyone can install your build at all. The right candidate doesn’t need it to be glamorous, but they need it to be theirs.

Shade is built on Python, NodeJS, Next.js, and C++ with a Postgres database. The frontend is React, TypeScript, and Electron. You wouldn’t write C++, but you’d integrate with it through the IPC layer between the desktop app and the ShadeFS process.

• Keep dependencies as minimal as possible. You are the summation of your subprocessors’/dependencies’ issues. To build a durable and reliable company you must be deliberate when you add dependencies and control the vision of all the code you ship.

• Monolith > microservices. Transactional everything requires one database.

• Solve the core issue. Don’t invent a Band-Aid. If a database query is slow, address it directly rather than reaching for a cache.

• The simplicity of fs.readFile() always wins. Have you tried to access files in a Dropbox local drive from your programs? It doesn’t work: files must be manually downloaded in their entirety to be accessed. We've built Shade to be accessible like a hard drive where files are streamed. Building an AI video editor? Works with Shade. Using n8n automations? Works with Shade. Using DaVinci Resolve? Works with Shade.

When we hire, we like to keep those hires. Because of that, we offer benefits on top of salary and equity:

• Free lunch (under $30)

• Free dinner (under $30) if you stay more than 9 hours

• Fully covered health insurance, including dental and vision

• 401k with % match

• Unlimited PTO

• Lifetime gym membership

• Commuter benefit for the subway

The greatest qualification in our eyes is that you can ship and maintain high volumes of quality code. If you’ve built side projects that thousands of people use, or worked at companies where you've owned frontend features end to end, we’re probably excited about you. What (we think) this looks like in bullet points:

• 4+ years of full-time engineering experience, with at least 2 years owning a production frontend end to end

• Strong React and TypeScript fundamentals; experience with Next.js and TanStack

• Production experience with Electron, including release workflows and over-the-air updates

• Comfort working in imperfect codebases; good judgment about when to clean up and when to ship

• Experience building interfaces that render complex media: video, audio, image previews. Bonus if you’ve worked on video tooling specifically.

• Experience at a pre-Series B startup

The strongest pattern in hiring has been people who’ve felt the file system pain firsthand. Brandon was a videographer; I directed films before I wrote code. You don’t have to be a creative, but you do have to understand that your user would rather be making something than managing files.

The second pattern is opinionatedness. We don’t have product managers. Decisions on the frontend happen between you, the design team, and me. That works best when the people in the room have strong opinions and can defend them.

The third is wanting to lay foundations. The right candidate wants to build the system, not ship on top of it.