Your Package Repository Doesn't Need a Platform
How we distribute Linux software using standard tools, a web server, and a little automation — and why understanding what you're paying for can reveal surprising opportunities to reduce IT costs.

Software infrastructure has a remarkable tendency to become more complicated than the problem it was originally supposed to solve.
Need to distribute an application? There are artifact management platforms for that. Need automated updates? Another managed service might help. Need repository hosting, access controls, release management, and distribution across different Linux systems? Before long, something that started as a relatively straightforward technical requirement can become another recurring subscription, another vendor relationship, and another component in an already crowded infrastructure.
Sometimes that complexity is justified. Often, however, it's worth asking a simpler question:
What does the underlying technology actually need to accomplish?
We recently encountered a good example while working on software distribution at Neoground. We wanted to distribute our own Linux desktop applications through native Debian and RPM packages, with proper package-manager integration and updates.
We already had the infrastructure: Linux servers, an automated build environment, and Caddy serving our web applications.
As it turns out, that's almost everything you need.
The surprisingly simple architecture of a Linux package repository
Most Linux users are familiar with installing software through a package manager:
sudo apt install my-app
Or on an RPM-based distribution:
sudo dnf install my-app
Behind these commands are sophisticated systems for dependency resolution, version management, cryptographic verification, and software installation.
But the servers providing the packages are often surprisingly simple.
An APT repository, for example, is essentially a directory of .deb files accompanied by generated indexes and cryptographically signed metadata.
An RPM repository follows much the same principle, using .rpm files and metadata such as repomd.xml.
Both can be served through an ordinary HTTP server.
No database is required. No specialized repository daemon. No continuously running application responsible for negotiating software updates with thousands of clients.
The package manager does the complicated work. The server provides the files.
This principle extends beyond Debian and Fedora. Arch Linux, Alpine Linux, and even Flatpak repositories use distribution formats that can be hosted over static HTTP.
Of course, the repository metadata must be generated correctly and cryptographic trust must be established. But mature tools already handle those responsibilities.
Let's look at how little infrastructure is actually necessary.
Building our own APT and RPM repositories
Our setup starts with electron-builder, which packages our Electron applications into native Linux formats.
On a Debian build host, generating both formats is as straightforward as:
electron-builder --linux deb rpm --publish never
We don't need separate Fedora and Debian build servers merely to generate the package formats.
Once the packages exist, we can publish them into their respective repositories.
For this example, we'll use a dedicated hostname, packages.example.com, and a simple directory structure:
/srv/packages/
├── apt/
│ ├── conf/
│ ├── db/
│ ├── dists/
│ └── pool/
├── rpm/
│ └── x86_64/
│ ├── *.rpm
│ └── repodata/
└── public/
├── apt/
├── rpm/
└── keys/
The working repository directories contain the data needed to generate releases. Only the generated public files are exposed through the web server.
Step 1: Create an APT repository with reprepro
On Debian, install the required utilities:
sudo apt install reprepro gnupg rsync
Create the repository configuration in /srv/packages/apt/conf/distributions:
Origin: Example Software
Label: Example Software
Codename: stable
Architectures: amd64
Components: main
Description: Example application repository
SignWith: YOUR_GPG_KEY_FINGERPRINT
The SignWith setting identifies the OpenPGP key used to sign the repository metadata. If you don't already have a dedicated signing key, you can generate one with:
gpg --full-generate-key
Use gpg --list-secret-keys --fingerprint to retrieve its fingerprint.
Now add a package:
reprepro -b /srv/packages/apt \
includedeb stable dist/my-app.deb
That's essentially the entire repository-generation process.
reprepro imports the package, updates the indexes, and signs the repository metadata using the configured key.
It generates files such as:
dists/stable/InRelease
dists/stable/Release
dists/stable/main/binary-amd64/Packages.gz
pool/main/...
APT understands these files natively. You don't need to implement a custom update mechanism.
For a simple desktop application, a distribution-independent stable suite can be sufficient, provided its dependencies are compatible with the Debian and Ubuntu releases you intend to support.
Step 2: Create an RPM repository with createrepo_c
The RPM equivalent is similarly straightforward:
sudo apt install createrepo-c rpm
Place your signed RPM packages in the repository directory and run:
createrepo_c /srv/packages/rpm/x86_64/
This creates the repodata directory containing the metadata DNF and other compatible package managers need.
For a production repository, sign the RPMs before generating the metadata, using rpmsign and a configured release-signing key.
The repository metadata itself can then be signed:
gpg --armor --detach-sign \
--local-user YOUR_GPG_KEY_FINGERPRINT \
/srv/packages/rpm/x86_64/repodata/repomd.xml
This produces repomd.xml.asc alongside the metadata file.
RPM supports cryptographic signatures on individual packages, while APT normally authenticates packages through signed repository metadata containing their checksums.
These details differ, but established tools already implement the required mechanisms. There's little reason to write them ourselves.
Step 3: Serve everything with Caddy
Now comes the infrastructure part.
Copy the public APT directories and the generated RPM repository into /srv/packages/public/, along with the public signing keys.
For example:
rsync -a /srv/packages/apt/dists/ \
/srv/packages/public/apt/dists/
rsync -a /srv/packages/apt/pool/ \
/srv/packages/public/apt/pool/
rsync -a /srv/packages/rpm/x86_64/ \
/srv/packages/public/rpm/x86_64/
Configure Caddy:
packages.example.com {
root * /srv/packages/public
file_server
}
That's the web server configuration.
Assuming DNS, HTTPS, and filesystem permissions are configured correctly, the repositories are accessible at:
https://packages.example.com/apt/
https://packages.example.com/rpm/x86_64/
Caddy handles HTTPS automatically. Package managers retrieve the files using ordinary HTTP requests.
No additional service is required to handle those requests.
Step 4: Let users install and update normally
On Debian or Ubuntu, users can register the APT repository with a modern deb822 source file.
First, the public key is installed into a dedicated keyring under /etc/apt/keyrings/. Then a file such as /etc/apt/sources.list.d/example.sources contains:
Types: deb
URIs: https://packages.example.com/apt/
Suites: stable
Components: main
Architectures: amd64
Signed-By: /etc/apt/keyrings/example.gpg
On Fedora, a .repo configuration is similarly compact:
[example]
name=Example Software
baseurl=https://packages.example.com/rpm/x86_64/
enabled=1
pkg_gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.example.com/keys/rpm.asc
The public signing keys must be published and their fingerprints verified when establishing trust. The RPMs and repository metadata must also be signed consistently with the configured keys.
Once the repositories have been configured, users install and update software through their normal package managers.
sudo apt update
sudo apt install my-app
Or:
sudo dnf install my-app
Subsequent updates become part of the operating system's ordinary update workflow.
The complete distribution infrastructure is based on standard packages, generated metadata, cryptographic signatures, and static files.
That's the interesting part.
The commands above demonstrate the essential setup rather than a complete hardened release pipeline. Production publishing should additionally validate artifacts, protect signing keys, stage releases, retain referenced files during updates, and test installation on supported distributions.
Automating the entire publication process
Of course, manually copying packages into directories isn't how we'd want to operate this in the long term.
Fortunately, that's another solved problem.
We already operate our own CI/CD infrastructure. Extending an existing release pipeline to publish Linux packages is a relatively small integration task.
The process becomes:
- Build the application and generate DEB/RPM artifacts.
- Validate the package metadata, versions, and architectures.
- Sign the RPM packages.
- Import packages and generate repository metadata.
- Sign the resulting repository metadata.
- Publish the validated repository files.
- Verify that the new release can be retrieved and installed.
This can be implemented with a few scripts and integrated into an existing CI/CD pipeline.
For production, publication consistency matters: clients must not encounter indexes referencing packages that haven't been uploaded yet or have already been removed. We therefore prefer staged publication, immutable package artifacts, and appropriate retention of older referenced files.
Those are engineering concerns worth addressing, but they don't require an enterprise repository platform.
The actual repository doesn't need to run any custom application code at all.
And because the underlying formats and tooling are mature, this isn't an integration that should need constant redevelopment.
What about maintenance, security, and scalability?
This is usually where the argument for outsourcing begins.
Surely maintaining a repository involves upgrades, security patches, reliability engineering, monitoring, and other operational responsibilities?
Yes. But the amount of maintenance should be evaluated according to the system's actual architecture.
The repository-generation utilities are mature components maintained by their respective communities. The web server is infrastructure we already operate. HTTPS, backups, monitoring, and CI/CD are existing capabilities.
We aren't maintaining a custom repository implementation. We're maintaining a small integration around established software.
Cryptographic keys need appropriate protection and eventual rotation. Servers require security updates. Build pipelines need to remain trustworthy. The publication process should be tested periodically.
None of these responsibilities disappears by operating the repository ourselves.
But importantly, they don't necessarily grow in proportion to the number of applications or developers using the repository.
A static repository serving a thousand downloads and one serving a hundred thousand downloads can use essentially the same architecture. Storage capacity, bandwidth, caching, and availability requirements might change. The underlying software distribution mechanism does not.
This is a distinction we consider important throughout infrastructure engineering: operational volume and operational complexity are not the same thing.
So why do commercial artifact management platforms exist?
There are legitimate reasons.
Products such as JFrog Artifactory and other enterprise artifact platforms provide capabilities beyond hosting APT or RPM repositories.
They may offer centralized artifact management across numerous ecosystems, fine-grained access controls, private dependency proxies, vulnerability scanning, approval workflows, retention policies, geographic replication, and integrations with enterprise identity and compliance systems.
For organizations that genuinely need those features, such products can be valuable.
But here's the question we would ask before recommending one:
Which of those capabilities does the organization actually need?
A company distributing a few internal Linux tools, several desktop applications, or its own software packages to customers may have no meaningful requirement for most of them.
If the goal is simply reliable package delivery and updates, buying a comprehensive artifact management platform can be disproportionate.
The challenge isn't that commercial platforms are inherently bad. It's that organizations sometimes evaluate products based on the features they offer rather than the requirements they need to satisfy.
And a platform that solves twenty problems isn't necessarily more economical when you only have two of them.
The hidden economics of specialized infrastructure services
This example illustrates something we frequently consider when evaluating technology spending.
An organization needs a particular capability. A specialized provider offers that capability as a managed service. The subscription seems reasonable, especially compared with the perceived effort of developing something internally.
Over time, however, these decisions accumulate.
A managed artifact repository here. A dedicated automation service there. Another monitoring platform, a hosted dashboard, a document processing API, an integration service, an additional SaaS product.
Each purchase might be individually defensible.
Collectively, they can create a substantial recurring cost structure.
And perhaps more importantly, each provider introduces another external dependency, another integration, another pricing model, and potentially another source of operational complexity.
Consider a hypothetical company paying €300 per month for a specialized service.
That's €3,600 annually, or €18,000 over five years, before price increases.
If an equivalent solution can be implemented using existing infrastructure with modest initial effort and minimal incremental maintenance, the economics may look quite different.
Of course, not every service can be replaced so easily, and internal engineering time has a cost. A fair comparison must account for implementation, maintenance, reliability, security, and the actual value of the service.
But recurring subscription costs shouldn't automatically be treated as unavoidable operating expenses.
Sometimes they're simply the consequence of never evaluating an alternative.
The question isn't just whether a service is worth its price
It's whether the underlying requirement could be satisfied more effectively through a different architecture.
That distinction matters.
A specialized provider might offer excellent value relative to its competitors while still being unnecessary for a particular customer.
The optimal solution might be an existing internal service, a small open-source component, an additional feature in software the organization already operates, or a few lines of automation.
This is why technology cost optimization should go beyond negotiating licenses or replacing one vendor with another.
It needs to examine the architecture behind the spending.
AI-assisted engineering changes the calculation further
There's another important development: the declining cost of implementing small, specialized software solutions.
Traditionally, building an internal integration might have required researching several tools, understanding their configuration formats, writing scripts, developing tests, and creating documentation.
That work still exists. But AI-assisted engineering can reduce the time required considerably.
For something like our package repositories, AI can help with the initial configuration, generate publishing scripts, investigate compatibility issues, produce automated tests, and document the deployment process.
This doesn't eliminate the need for engineering expertise.
In fact, expertise becomes particularly important when assessing whether the resulting architecture is appropriate, reliable, and secure.
But the economics are changing.
Tasks that previously appeared too small to justify allocating developer time can now become practical, especially when they involve connecting mature components through standardized interfaces.
We don't need AI to reinvent APT or RPM. Those ecosystems already work remarkably well.
We can use AI to make the integration of existing technologies faster, cheaper, and more accessible.
That is a considerably more sustainable approach than replacing established infrastructure with unnecessary custom software.
Why we approach technology spending differently
At Neoground, we work with both the engineering and strategic sides of technology.
That means we're interested not only in whether a system works, but whether its architecture makes sense for the organization operating it.
Our own infrastructure is a practical testing ground for that philosophy.
We operate Linux systems, self-hosted applications, deployment pipelines, and other technical services where maintaining control over our architecture offers real advantages.
Not because every service should be self-hosted, but because we understand the underlying technologies well enough to make that decision deliberately.
Our package distribution infrastructure is a small example.
There's no need to introduce a commercial artifact platform for requirements that existing tools and infrastructure can already satisfy. We can publish native software packages, support automatic updates, and maintain a straightforward release process without introducing a new operational dependency.
The incremental infrastructure cost can be very small when the required capabilities already exist.
That's precisely the kind of opportunity we look for in our broader technology-spend reviews.
Instead of starting with a vendor comparison, we investigate the requirement itself.
What is the organization trying to accomplish? Which capabilities does it already have? Where is complexity being duplicated? Which subscriptions provide genuine value, and which exist primarily because an alternative was never seriously considered?
The answers can reveal opportunities that a conventional procurement or licensing review would miss.
Simplicity is an architectural advantage
There's a tendency to associate professional infrastructure with elaborate platforms, extensive dashboards, and increasingly specialized services.
But sophistication doesn't have to mean complexity.
A well-designed system can be small, standardized, secure, reliable, and remarkably inexpensive to operate.
Sometimes a static directory, a cryptographic signature, and a web server are exactly the right tools for the job.
Our Linux package repositories are one example. The same principle applies to many other areas of IT infrastructure, automation, integration, and software operations.
Before introducing another platform, it's worth understanding what the existing technology already provides.
Before accepting another recurring subscription, it's worth examining the actual requirements.
And before assuming that operating something internally would be too expensive or complicated, it's worth revisiting that assumption in light of modern tooling and AI-assisted engineering.
Good technology decisions aren't about maximizing the number of services an organization uses. They're about achieving the required outcomes with the right amount of complexity, cost, and control.
Sometimes that means choosing a managed provider.
And sometimes it means realizing that the solution was already within reach.
At Neoground, we help organizations evaluate technology decisions from both strategic and technical perspectives. Our Technology Spend Review examines infrastructure, software, vendor relationships, and existing capabilities to identify practical opportunities to reduce costs and unnecessary complexity — without compromising reliability or long-term flexibility.
Technical references
- Debian Wiki: Setting up a repository with reprepro
- Debian APT source configuration
- RPM package signing documentation
- DNF5 repository configuration
- Caddy static file serving