Blob Storage in FlexVertex: Assets Without Limits
Many modern platforms treat large assets as second-class citizens, forcing developers to store them outside the database and manage the connections themselves.
FlexVertex takes a different approach: large assets — including documents, training corpora, images, models, and serialized object collections — are stored using standard S3-compatible blob storage while remaining fully integrated with the FlexVertex object model.
This allows FlexVertex to scale from embedded deployments to distributed clusters while keeping large objects accessible, secure, and transactionally coordinated.
Why It Matters
In most systems, large objects are pushed into external storage systems and referenced only by opaque pointers.
That separation introduces problems:
Security policies must be duplicated across systems
Versioning becomes inconsistent
Transactions cannot coordinate object updates with binary data
Moving between local and distributed environments requires code changes
FlexVertex was designed to eliminate those gaps.
Instead of treating blob storage as an external dependency, FlexVertex integrates it directly into the platform through FlexStorageObject proxies.
This preserves security, metadata, and transactional consistency while allowing extremely large objects to live in scalable object storage.
Inside the FlexVertex Blob Architecture
FlexVertex uses the S3 protocol as its standard interface for blob storage. The protocol provides a widely adopted and interoperable way to store and retrieve large objects while remaining independent of any specific vendor implementation.
The default implementation uses MinIO, selected for several reasons:
Open source and widely deployed
Strong consistency guarantees
Distributed architecture that fits FlexVertex clustering
Built-in versioning capabilities
Secure and easy to operate across environments
FlexVertex writes and retrieves blobs using the pure S3 protocol, which allows the same system to operate:
locally on a single machine
in embedded environments
across distributed clusters
in cloud deployments
without application changes.
Transparent Storage Routine
FlexVertex automatically determines how large objects are stored.
Smaller objects may remain directly inside FlexVertex storage structures. Once an object reaches a certain size threshold, it is automatically stored in S3-compatible storage instead. This transition is transparent to developers.
FlexStorageObject Proxies
Each stored blob is represented inside FlexVertex by a FlexStorageObject.
This proxy object:
stores metadata
enforces security policies
participates in the normal FlexVertex object graph
integrates with transactions and queries
The underlying blob itself remains opaque and is accessed only through this proxy layer.
Transaction-Safe Blob Ingestion
Very large assets may take significant time to upload.
FlexVertex handles this safely using a staged process:
The binary object is written to S3 storage.
A temporary TTL is applied to ensure incomplete uploads are cleaned up.
Once the upload completes successfully, the FlexStorageObject is created inside FlexVertex.
The TTL is removed and the object becomes part of the transactional system.
If the transaction fails before completion, the blob automatically expires and is deleted.
This mechanism preserves ACID guarantees while supporting very large data ingestion.
Embedded and Local Blob Storage
FlexVertex also includes a local S3 proxy implementation for environments where running MinIO or cloud object storage is unnecessary.
This allows blob storage to operate entirely on the local filesystem while still using the same S3 protocol interface and FlexStorageObject abstractions.
Applications therefore move from:
embedded devices
single machines
distributed clusters
without rewriting storage logic.
Takeaway
Blob storage in FlexVertex isn’t a bolt-on feature.
By standardizing on the S3 protocol while integrating assets through FlexStorageObject proxies, FlexVertex allows massive binary objects to live inside the same logical environment as structured data.
Developers gain:
seamless scaling from local to distributed deployments
secure, versioned asset storage
transactionally coordinated ingestion
unified access through the FlexVertex object model
The result is a platform where structured data, relationships, and large assets coexist naturally.