Running and open-sourcing a small app on DigitalOcean with Git

## The open-sourcing part is just Git

There’s no separate “make it open source” step. It’s the same Git commands you already use:

• git init, commit, push to a public GitHub repo. That’s the code out in the world.
• Add a LICENSE file so people know they’re allowed to use it. One file.
• Open a few issues describing things the app is missing. Tag the approachable ones good first issue.

That’s it. From that point on, everything runs on Git primitives anyone can use: someone forks the repo, makes a branch, opens a pull request. GitHub Actions runs the checks on that PR automatically. When a change is good, it merges. When enough has piled up, you tag a version and cut a release. Nobody needs commit access, nobody needs a meeting — a fork and a PR is the entire protocol, and it’s the same one used by projects a thousand times this size.

## Why DigitalOcean makes this easy specifically

The part that usually kills a small open-source project isn’t Git, though. It’s that a contributor can’t easily run the thing to test their change. That’s where the hosting choice quietly matters.

App Platform builds a contributor’s fork the same way it builds mine: connect a repo, it detects Python, installs the requirements, and runs it. No Dockerfile to keep in sync, no build config to explain in the README. And because it’s connected to Git, every push redeploys on its own — the deploy step is just git push, for me and for anyone who forks it.

Storage is the same story. Spaces speaks the S3 API, so there’s no proprietary SDK for a contributor to learn before they can help. The upshot is that the setup instructions fit in a paragraph: clone the repo, set four environment variables, run python app.py. A contributor sees exactly what I see, without standing up any infrastructure. When helping is that cheap, people actually help.

## What that added up to

I left the repo alone with a handful of small issues, and over about a week contributors I’d never met turned it into something real:

• Upload validation with clear error messages.
• A delete button on each image, wired to remove the object from Spaces.
• Pagination, so a full bucket doesn’t render one giant page.
• Thumbnails generated with Pillow on upload.
• A copy-URL button, an image count in the header, an empty-state screen with a favicon.
• A pytest suite that runs in CI.

That’s five releases, v0.1.0 through v0.4.0, most of the work coming through ordinary pull requests. A couple were somebody’s first open-source contribution. None of it required anything more exotic than Git and a stack that any of them could run locally.

## You can lift the Spaces part into your own app

One practical takeaway: the code that talks to Spaces is worth stealing on its own. It’s not a library, but the reusable core is about forty lines, and it drops into any Python app that needs user uploads. The one thing to get right is the endpoint, because the panel shows you a URL that boto3 doesn’t want:

# The panel shows https://<bucket>.<region>.digitaloceanspaces.com.
# boto3 wants the REGION endpoint and adds the bucket itself:
endpoint = f"https://{region}.digitaloceanspaces.com"

client = boto3.session.Session().client(
    "s3",
    region_name=region,
    endpoint_url=endpoint,
    aws_access_key_id=key,
    aws_secret_access_key=secret,
    config=Config(signature_version="s3v4"),
)

After that it’s the S3 API you already know: put_object with ACL="public-read" to make an image loadable in a browser (buckets are private by default), list_objects_v2 to read them back, a few lines of Pillow for thumbnails.

## Try it

The repo is github.com/oceanforge/spaces-gallery. It runs on App Platform’s trial credit, it’s MIT, and there are still good first issues open — a download button, configurable upload limits, Cache-Control headers for the CDN, a JSON API, a lightbox. If you want a small, working reference for “images on Spaces,” or a friendly repo to make a first contribution against, it’s right there.

The point I’d leave you with: open-sourcing a small app is much less work than it sounds. Git handles the collaboration, App Platform handles the “does it run on someone else’s machine,” and you’re left with the fun part — building the thing.