D
anielle Daniv
←Home
RepoFlow.io · 2026
RepoFlowRepoFlow: A new kind of package management

Overview

How I designed a B2B platform that simplifies complex developer package management — owning the experience end to end, from the first concept to a live product used by 40+ engineering teams.

Role

Sole Founding Product Designer

The Team

1 CEO & Developer
1 Founding Product Designer

BACKGROUND

Code is rarely built from scratch.

Modern software runs on thousands of pre-built packages — libraries pulled in rather than written from zero. DevOps engineers manage them in repositories: storage, access, compliance. Developers use them daily — finding packages, pulling versions, checking what's safe. Without an interface, both workflows default to scripts and file-hunting.

THE MARKET GAP

Managing developer packages became harder than it needed to be.

Audience Mismatch

The products on the market were designed for large enterprises — complex setups, big budgets and features most teams never use.

The UX Demand

Engineers wanted a better experience.
They searched for workarounds — some went as far as building their own interfaces.

Lack of Alternatives

There was no middle ground — either too much or not enough. Most teams paid for the enterprise option and lived with it.

This wasn't just one team's frustration:

Across developer communities, the same frustration kept surfacing.

When enterprise tools ignore UX, users build their own product-market fit. We decided to build a product around it.

We saw what others ignored — and built around it.

Our CEO had lived this problem firsthand — he'd been the user before he became the builder. He brought me on as the founding product designer with one brief: make experience the reason teams choose RepoFlow. I owned the product end to end — research, every screen, the design system, from first concept to what's live today.

SOLUTION

RepoFlow: Experience-first package management.

A B2B platform built for engineering teams to manage private and public packages — in the cloud or on your own servers. RepoFlow is a modern, clearer way to manage repositories — shaped around how teams actually work.
Users1,500+
Used by40+ teams
Live since2025

Browse repositories

Create your first repository

RESEARCH

What were teams actually living with?

I audited the dominant platforms end to end, interviewed the engineers using them, and listened to developer communities talk about the pain — unfiltered. The same pattern, everywhere.

Their tool creates more work than it removes.

DevOps engineers end up doing design work just to keep things running — building custom interfaces, writing training docs, hand-holding developers through basic tasks. The product was supposed to save time. It was stealing it.

Nothing is findable by the people who need it most.

One DevOps engineer I spoke with had built her own interface on top of the tool her team was paying for — just so developers could find packages without training and without breaking anything. She had become an unpaid UX designer to compensate for what the product refused to do.

One interface. Two users. Designed for neither.

DevOps manages systems. Developers use packages. The tool treated them identically — same screens, same complexity. Both were fighting an interface built for neither.

DESIGN DECISIONS

The decisions that made RepoFlow different.

01 — A repository-centered workspace, shaped by role.

Repositories = Home. Most tools separate viewing from configuring. It's easier and cheaper to build — it simply mirrors how the system is wired underneath. But it forces that structure onto the user. For DevOps, every change becomes a context switch. In RepoFlow, I centered everything on the repository. View, manage, configure, all around one place. DevOps stays in control and move faster.

Structure: RepoFlow vs. Competitors

Manage where you work. Everything lives under the repositories.

View in one place, manage in another.

Shaped by role. I built one screen that adapts to whoever's on it. DevOps sees full controls. Developers see the same screen, focused on their permissions. Access levels are set once in the Workspace Settings, and what each person sees follows from that — so the same surface fits a team where developers can publish packages and one where they only browse.

02 - Developers deserve to search, not dig.

Most developer tools manage packages the way a computer manages files — folders inside folders. Storage works that way, so the interface mirrors it. The easy move was to keep that structure.

I removed the file tree and made the package a first-class entity — version, description, everything you need to evaluate it without clicking in. That's the unit you see, search, and act on.

Files vs. packages — two different models.

Navigate folders to find a package.

Navigate folders to find a package.

Browse or search packages.

Browse or search packages.

Search followed the same logic. In file-based tools, searching returns names — the developer navigates in to find out what they found. I built search around recognition over recall: name, version, a short description surfaced in every result. Search now spans every repository and reaches inside READMEs. 

DESIGN SYSTEM

0→1 startup design system.

At a startup, a design system maybe isn't a best practice — but at RepoFlow, we knew experience would be the differentiator. I built it minimal and grew it in chunks as the product evolved, keeping it clear enough for the CEO to build independently when needed.
Colors

Colors

I chose a light, monochrome base with a single accent color — a deliberate contrast to the dark-mode terminal aesthetic most developer tools default to. Bright and minimalist, it builds trust fast and lowers the barrier for every type of user on the platform.

THE PRODUCT

A. Retention rules

Every code push adds packages, builds, and versions to the repository. Without rules to clear them out, storage grows fast and compliance windows are hard to control. With this feature, DevOps get the power and flexibility to define what gets deleted, when, and under what conditions — automatically.
1. Management console

1. Management console

A rule isn't a setting you configure once — it's a process. I designed the table to reflect that: active status, next scheduled run, past results.

4. Build your rule - Start from scratch

4. Build your rule - Start from scratch

Progressive disclosure inside a complex form — condition groups collapse so the rule stays readable as it grows. The right panel shows a live summary: every choice, its consequence, in plain language.

5. Dry run your rule

5. Dry run your rule

Before anything is deleted, DevOps sees exactly what would be affected — down to the count and size. Confidence before commitment.

Videos of the entire feature:

Create new rule → Start with AI → Dry Run

UI Builder

Retention rule - Actual Run

B. Uploading packages

Every package type has different rules. I made them visible upfront - before anything is uploaded. Inline validation catches issues as you go, and error messages name exactly what’s wrong and why.

C. Create a new repository

Each repository type has a different setup. Virtual is a combination of repositories — order determines where packages are found first. I designed reorderable blocks instead of inputs: drag to set the order, position does the work.

REFLECTION

What I learned

In a two-person team, the designer is the only user advocate.

At a startup, there's no design team to push back, no one else asking "but what does the user need here?" I learned to carry that question myself — through every delivery decision, every moment where experience and speed pulled in different directions.

Speed and quality aren't opposites

As a sole designer at a startup, you learn fast that not every decision carries the same weight. Over time, I developed a simple discipline - rating user value and implementation effort from 1 to 10 — an effort impact matrix. High impact, low effort - protect it. Low impact, high effort: - let go. That's what lets you move fast without losing what matters.

RepoFlow is live. Teams choose it for the experience. That's the brief I was given on day one — and it's what we built.