Drop & Dropthis

A parallel lane to Git. Stop sharing API keys and internal documentation over Slack. Drop syncs the secrets and private artifacts that do not belong in your repository.

Comment 1

Inspiration

Git solved source code collaboration decades ago, but modern software projects have evolved far beyond source code. Every project now depends on environment variables, private documentation, AI prompts, MCP server configurations, datasets, local caches, certificates, models, internal artifacts, and even conversations with AI coding assistants.

These resources are essential for reproducing a working development environment, yet they don't belong in a Git repository. As a result, developers resort to manually sharing files through Slack, Discord, cloud drives, or private messages whenever they switch devices or onboard new teammates.

We wanted to build the missing piece of the modern developer workflow: a secure, Git-inspired way to synchronize everything that makes a project usable, without compromising security or cluttering the repository.

What it does

Drop is an end-to-end encrypted synchronization system designed specifically for developers.

Rather than replacing Git, Drop complements it by managing everything that should not be committed to a repository.

With Drop, developers can securely synchronize:

  • Environment variables (.env files)
  • Certificates and private keys
  • Internal documentation
  • AI prompts
  • Conversations with coding agents
  • MCP server configurations
  • Local development settings
  • Test datasets
  • Machine learning models
  • Generated artifacts
  • Local caches
  • Any other private project resources

The workflow intentionally mirrors Git, making it instantly familiar:

  • drop add
  • drop push
  • drop pull

Files are encrypted before leaving the user's machine, allowing developers to seamlessly continue working from another computer or securely onboard new teammates.

DropThis is our managed cloud service built on top of Drop, providing the same experience without requiring users to host their own infrastructure.

How we built it

We designed Drop around three core principles:

Developer Experience. Instead of inventing an entirely new workflow, we adopted Git's mental model so developers can become productive immediately.

Security by Default. Every file is encrypted locally before upload using end-to-end encryption. The server only stores encrypted blobs and never has access to plaintext data.

Repository Awareness. Drop associates synchronized resources with Git repositories while keeping them completely separate from the Git server itself. This allows both systems to coexist without interfering with one another.

The project consists of two main components:

  • Drop, the open-source synchronization engine and CLI.
  • DropThis, a hosted cloud platform that provides authentication, encrypted storage, synchronization, and device management with minimal configuration.

Challenges we ran into

One of our biggest challenges was designing a workflow that feels immediately familiar without simply cloning Git.

Another challenge was defining exactly what belongs in Drop. We wanted to avoid becoming "Dropbox for developers" and instead focus on solving a very specific problem: synchronizing the complete development environment while leaving source code management to Git.

Security was another major consideration. We wanted encryption to be transparent for users while ensuring that servers never have access to unencrypted project data.

Finally, we spent significant time thinking about the developer experience. Powerful tools are only valuable if developers actually enjoy using them, so simplicity became a core design goal.

Accomplishments that we're proud of

We're proud that Drop solves a problem every developer has experienced but that surprisingly few tools address directly.

Instead of asking developers to learn another completely different workflow, Drop feels immediately familiar by embracing Git's philosophy.

We're also proud of building security into the foundation of the project instead of treating it as an afterthought. Every synchronized file remains encrypted from the moment it leaves the user's computer.

Perhaps our favorite accomplishment is the project's vision. Modern software development is no longer just about source code. AI workflows, prompts, datasets, models, caches, and local configuration have become first-class citizens of the development process, and Drop is designed around that reality.

What we learned

Building Drop reinforced an important lesson: today's software projects are complete development environments, not just repositories.

We also learned that developer experience matters as much as technical capabilities. Familiar commands, predictable behavior, and seamless integration often provide more value than introducing entirely new concepts.

Finally, we realized that AI-assisted development is fundamentally changing what developers need to synchronize. Prompts, agent conversations, MCP configurations, and generated artifacts are becoming just as important as the code itself.

What's next for Drop & DropThis

Our vision extends far beyond synchronizing secrets.

Future versions will include:

  • Automatic workspace synchronization
  • Team collaboration and encrypted sharing
  • Selective synchronization profiles
  • Device management
  • Version history and rollback
  • Conflict detection and resolution
  • Background synchronization daemon
  • Native integrations with popular IDEs
  • AI workflow synchronization
  • MCP server discovery and distribution
  • Secure team onboarding
  • Self-hosted enterprise deployments
  • Plugin ecosystem
  • Public SDK for third-party integrations

Long term, we envision Drop becoming the standard companion to Git.

Git will continue to synchronize source code.

Drop will synchronize everything else.

Together, they will make moving between devices, onboarding developers, and reproducing complete development environments as effortless as cloning a repository.

Built With

Share this project:

Updates