Independent software studio

Small studio. Serious software.

Beratna Labs builds and ships its own software. Two products are out and in real use — Portari for managed file transfer, CoverText for Shopify accessibility — with more on the bench behind them, each carrying its real status rather than the marketing version.

  • Built in the open
  • Accessible by default
  • Documented as we go
  • No dark patterns
Built to last Maintainable by design, not by luck
Accessible WCAG AA as the baseline
Fast Performance budgeted from the start
In the open Real status, no vapourware

How we build

Six things we don't cut corners on

None of this is novel. It's just the set of habits that separates software you can still trust in five years from software that quietly rots.

Correctness before cleverness

A clever solution nobody can reason about is a liability. We'd rather write the obvious version, prove it behaves, and keep it readable than win an argument about elegance.

Performance is a requirement

Speed gets budgeted at the start, not bolted on after someone complains. Pages and screens are measured on real hardware, not just whatever is on our desk.

Accessible by default

Keyboard navigation, sane contrast, real labels, and markup that means something to a screen reader. Treated as part of "finished" rather than a later ticket nobody picks up.

Documented while we build

Notes written at the moment a decision gets made, not reconstructed months later from memory. Future us is a different person, and they deserve better than a guess.

Your data stays yours

No selling it, no quietly mining it, no burying the terms in a settings page six clicks deep. If a feature only works by harvesting something, we'd rather not ship the feature.

Boring, durable technology

We pick tools that will still be maintained in five years over whatever trended last month. Novelty is a cost, and it's usually paid by whoever maintains the thing next.

From idea to beta

How something becomes real

Every item on our roadmap sits at one of these four stages, and we label it honestly — including the ones barely off the ground.

01 · Research

Is this worth solving?

We talk to people who actually have the problem before writing anything. Plenty of ideas die here, which is the cheapest place for them to die.

02 · Design

What is it, exactly?

Scope, screens, and the data model get worked out on paper first. We decide what the thing deliberately will not do, which matters as much as what it will.

03 · Build

Make it work, properly

Code, tests, and documentation together. The goal at this stage isn't a demo — it's something that holds up when a real person uses it on a bad day.

04 · Beta

Put it in real hands

A small group uses it for real work and tells us what's wrong. It only leaves beta when we'd be comfortable depending on it ourselves.

Our approach

Patient by design

Software gets worse when it's rushed to hit a date somebody picked in a meeting. We've set this studio up so we don't have to do that.

  • We ship when it's right, not when a quarter ends. No arbitrary launch date to work backwards from, so quality doesn't become the thing that gets cut.
  • We build things we'd use ourselves. Every idea here started as a problem we hit directly. It's a narrow filter, and a good one.
  • Every idea has to survive "should this exist?" If something already solves the problem well, the right move is to use that and go work on something else.
  • Status on this site is the real status. If something is at eight percent, it says eight percent. We'd rather look early than look dishonest.
Beratna Labs logo

The toolkit

Boring tools, chosen on purpose

Technology picked because it will still be maintained in five years — not because it was trending last month.

  • C#
  • .NET
  • HTML5
  • CSS3
  • JavaScript
  • TypeScript
  • React
  • Node.js
  • Python
  • PostgreSQL
  • Powershell
  • SQL Server
  • REST & JSON APIs
  • Azure
  • AWS
  • Docker
  • Git
  • CI/CD
Live now

Two products you can actually run

Portari moves files between systems you don't control and accounts for every one of them. CoverText finds the images in a Shopify store that are missing alt text and writes it. Behind them is a roadmap with honest status attached to every item, including the ones barely started.

See what's on the bench

Stay in the loop

Know when the next one ships

One email when something enters beta. No newsletter, no drip campaign, no selling your address to anyone.