An API is a contract. It should behave like one.
Red Sentra designs and builds APIs, and connects systems to the ones that already exist — including the protocols that are hostile, stateful or badly documented.
Responsibility
What we take on.
- API design: the shape, the versioning and what it refuses to do
- Implementation, including the services behind the interface
- Integration with systems and protocols that already exist
- Protocol boundaries, so a failure on one side stays on that side
- Operation of the interface once other people depend on it
Engineering
One contract over several implementations
Four speech decoder architectures behave differently enough that the usual answer is four services. RustSTT is one, because a decoder abstraction holds a single frame shape across all of them.
Choosing which model serves a stream stops being an integration concern for anyone downstream. That is what an interface is for, and it is a design decision rather than a framework choice.
Protocol boundaries contain failure
Vestry speaks MTProto, a stateful protocol that is not under our control and does not fail politely. The layer that speaks it holds session state alone and is isolated from the product services behind it, so protocol failure cannot become a product outage.
Behind that boundary, four Rust services talk over gRPC with Protocol Buffers as the contract. The internal interface is explicit for the same reason the external one is.
Integrating with what is already there
Integration work is usually not the happy path: an inverter that answers on its own schedule, a platform SDK with undocumented behaviour, a partner API that returns two hundred with an error in the body.
Sentinel Solar talks directly to the inverter from a small computer at the installation and holds telemetry on site, because a system that assumes connectivity as a precondition fails in the field.
Most of what gets called systems integration is this: two systems that were designed without each other in mind, and a contract invented afterwards to sit between them. The work is deciding where that contract goes and which side absorbs the surprises.
Streaming, not just request and response
RustSTT is a WebSocket API that emits partial transcripts while audio is still arriving, and reports its real-time factor so a caller can tell whether it is keeping up.
An interface that only exists in the request-response shape pushes the hard part — backpressure, partial results, what a slow consumer does — onto whoever integrates with it.
Evidence
Systems this rests on.
Each entry names the contribution Red Sentra declared on that system. Nothing here is cited for work the content model does not carry.
RustSTT
Four decoder architectures behind one WebSocket API, with a decoder abstraction holding a single frame shape so callers never choose a model.
Vestry
The MTProto-facing layer isolated so that protocol failure does not leak into the product services, with gRPC and Protocol Buffers as the internal contract.
Sentinel Solar
A local backend that talks directly to the inverter at the installation and holds telemetry on site rather than assuming the network is available.
Limits
What this page does not claim.
- No request volume, latency figure or throughput number is published for any interface described here.
- No partner whose API was integrated is named, and no third-party platform is described as endorsing Red Sentra.