# serialization-format

Published articles for serialization-format.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Using Large ONNX Models with External Data in Vespa Embedders

DevFeed: [Using Large ONNX Models with External Data in Vespa Embedders](<https://devfeed.tech/articles/using-large-onnx-models-with-external-data-in-vespa-embedders-12794.md>)

Original publisher: [Read original article](<https://blog.vespa.ai/onnx-external-data-in-vespa-embedders/>)

Author: bjorncs thomas

Published: 2026-03-27T00:00:00Z

Content type: tutorial

Language: en

Sources: [Vespa Blog](<https://devfeed.tech/sources/vespa-blog.md>)

Topics: [onnx](<https://devfeed.tech/topics/onnx.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [authentication](<https://devfeed.tech/tags/authentication.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [files](<https://devfeed.tech/tags/files.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [models](<https://devfeed.tech/tags/models.md>), [onnx](<https://devfeed.tech/tags/onnx.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>)

### AI overview

Vespa embedders now support large ONNX models whose weights are stored in external data files. Starting with Vespa 8.544, Vespa automatically downloads referenced external files when loading URL-based models, with support for private models through propagated authentication tokens. The feature is limited to embedders and supported model references.

### Source excerpt

Many ONNX models exceed the 2GB protobuf limit and store weights in external data files. Vespa now supports these models for embedders.

## The maturity gap in ML pipeline infrastructure

DevFeed: [The maturity gap in ML pipeline infrastructure](<https://devfeed.tech/articles/the-maturity-gap-in-ml-pipeline-infrastructure-13263.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/the-maturity-gap-in-ml-pipeline-infrastructure>)

Published: 2026-01-26T00:00:00Z

Content type: opinion

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Security](<https://devfeed.tech/topics/security.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [PyTorch](<https://devfeed.tech/topics/pytorch.md>)

Tags: [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [attacks](<https://devfeed.tech/tags/attacks.md>), [chainguard-pytorch-image](<https://devfeed.tech/tags/chainguard-pytorch-image.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [machine-learning-pipelines](<https://devfeed.tech/tags/machine-learning-pipelines.md>), [ml](<https://devfeed.tech/tags/ml.md>), [ml-ops](<https://devfeed.tech/tags/ml-ops.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [python](<https://devfeed.tech/tags/python.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [secure-by-default](<https://devfeed.tech/tags/secure-by-default.md>), [security](<https://devfeed.tech/tags/security.md>), [security-best-practices](<https://devfeed.tech/tags/security-best-practices.md>), [serialization](<https://devfeed.tech/tags/serialization.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

This article argues that ML pipeline infrastructure in 2026 has a security maturity gap: common tooling does not yet provide the secure-by-default protections expected in software engineering. It examines risks including data poisoning, model laundering, and insecure model serialization, and discusses short-term mitigations and longer-term industry improvements.

### Source excerpt

ML pipelines in 2026 still lack secure-by-default tooling. Learn the key security gaps in ML Ops and how teams can reduce risk today.

## Scaling Nextdoor's Datastores: Part 3

DevFeed: [Scaling Nextdoor's Datastores: Part 3](<https://devfeed.tech/articles/scaling-nextdoor-s-datastores-part-3-20342.md>)

Original publisher: [Read original article](<https://engblog.nextdoor.com/scaling-nextdoors-datastores-part-3-e9b4dd8a9393?source=rss----5e54f11cdfdf---4>)

Author: Ronak Shah

Published: 2025-03-19T15:08:43Z

Content type: article

Language: en

Sources: [Nextdoor](<https://devfeed.tech/sources/nextdoor.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [schema-evolution](<https://devfeed.tech/topics/schema-evolution.md>), [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Django](<https://devfeed.tech/topics/django.md>), [Python](<https://devfeed.tech/topics/python.md>), [Redis](<https://devfeed.tech/topics/redis.md>), [valkey](<https://devfeed.tech/topics/valkey.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cache-invalidation](<https://devfeed.tech/tags/cache-invalidation.md>), [caching](<https://devfeed.tech/tags/caching.md>), [compatibility](<https://devfeed.tech/tags/compatibility.md>), [database](<https://devfeed.tech/tags/database.md>), [django](<https://devfeed.tech/tags/django.md>), [lua](<https://devfeed.tech/tags/lua.md>), [python](<https://devfeed.tech/tags/python.md>), [redis](<https://devfeed.tech/tags/redis.md>), [schema](<https://devfeed.tech/tags/schema.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>), [thundering-herd](<https://devfeed.tech/tags/thundering-herd.md>), [valkey](<https://devfeed.tech/tags/valkey.md>)

### AI overview

Part 3 of Nextdoor's datastore-scaling series explains how applications serialize database objects for Redis or Valkey look-aside caches. It describes compatibility problems caused by runtime, package, and schema changes, including cache misses and thundering-herd effects during migrations.

### Source excerpt

In this part of the Scaling Nextdoor's Datastores blog series, we'll explore how the Core-Services team at Nextdoor serializes database data for caching while ensuring forward and backward compatibility between the cache and application code. In part 1 of this series we discussed how ORMs, object-relational mapping frameworks, help abstract away database specific schemas and queries from application code. Developers simply utilize objects in their application's language to access database data. Here's a simple example of using Python's Django ORM to define a model: from django.db import models class Users(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) The associated SQL create table would look like: CREATE TABLE users ( "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY, "first_name" varchar(30) NOT NULL, "last_name" varchar(30) NOT NULL ); Developers would then access database data like this: user_id = 123 user = User.objects.get(id=user_id) print(user.first_name)Object Byte Serialization for Caching An issue arises when adding a look-aside cache such as Redis/Valkey to an application: How do you store what you got from the database in the cache? A common solution to caching complex objects, such as those from ORMs, is object byte serialization. This process converts language objects into bytes before storing them in the cache. When reading from the cache the process is done in reverse where the byte data is turned into language objects. For instance in Python this is often done with the pickle package. The interaction between the application, database, and the cache looks like this: Look-Aside Cacheimport pickle # Try getting from cache ('None' if not in cache) user_bytes = cache.get("user_123") if user_bytes is not None: # Read bytes using pickle user = pickle.loads(user_bytes) else: # Fetch from database user = User.objects.get(id=123) # Convert to bytes user_bytes = pickle.dumps(user) # Sto

## Data replication across backend services with Kafka and Protobuf

DevFeed: [Data replication across backend services with Kafka and Protobuf](<https://devfeed.tech/articles/data-replication-across-backend-services-with-kafka-and-protobuf-20096.md>)

Original publisher: [Read original article](<https://medium.com/jobteaser-dev-team/data-replication-across-backend-services-with-kafka-and-protobuf-cad1d9fd9f90?source=rss----bd77d16a0035---4>)

Author: Emmanuel Joubaud

Published: 2023-04-14T10:01:57Z

Content type: tutorial

Language: en

Sources: [JobTeaser](<https://devfeed.tech/sources/jobteaser.md>)

Topics: [Back end](<https://devfeed.tech/topics/backend.md>), [Kafka](<https://devfeed.tech/topics/kafka.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [data-architecture](<https://devfeed.tech/topics/data-architecture.md>), [API](<https://devfeed.tech/topics/api.md>), [Structured-data](<https://devfeed.tech/topics/structured-data.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [backend](<https://devfeed.tech/tags/backend.md>), [data](<https://devfeed.tech/tags/data.md>), [data-replication](<https://devfeed.tech/tags/data-replication.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [replication](<https://devfeed.tech/tags/replication.md>), [serialization](<https://devfeed.tech/tags/serialization.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>)

### AI overview

This tutorial explains Jobteaser's Silos architecture for replicating data across backend services. It describes using Kafka topics and Google Protobuf messages so consumer services can maintain local database copies while avoiding synchronous service-to-service API calls.

### Source excerpt

The Jobteaser application contains a lot of different relatively independent modules to help universities provide career guidance to students: a job board, a career event management system, a career advice appointment management system... When we decided to migrate our application's backend from a monolith to a service-oriented architecture, we strived to keep each module as isolated as possible from the others in the event of an incident. If the career appointment system was down, students should still be able to browse and apply to job ads. That isolation is achieved through what we've called our Silos architecture. The gist is we avoid synchronous API calls between backend services, and prefer asynchronous data integration between services. There are a lot of different ways to implement asynchronous communication between services, and few companies share the details of theirs so we had to figure out a lot of stuff on our own. Now that we've refined our system, we thought we'd share the details of our approach, based on simple data replication using Kafka and Protobuf. How it worksWhen a write operation happens, data is changed first on the Source of Truth service, who then publishes it to a Kafka topic that consumers can subscribe to, in order to replicate their own local copy in their databaseSource of Truth and consumers Every table in our data model has an owner service, also called the Source of Truth (SoT) for that data, or the producer. For instance, the job board service may be the SoT for the job ad data. The owner service has 3 main responsibilities: it receives and validates all write requests for the data it owns (Create, Update, Delete) it stores the data to its own database, i.e. the Source of Truth, the authoritative state of the data if it's data that other services might want to access, it publishes its latest state as a message into a Kafka topic Consumer services that are interested in accessing a given table can then subscribe to the Kafka topic

## Caching Without Marshal Part 2: The Path to MessagePack

DevFeed: [Caching Without Marshal Part 2: The Path to MessagePack](<https://devfeed.tech/articles/caching-without-marshal-part-2-the-path-to-messagepack-1338.md>)

Original publisher: [Read original article](<https://shopify.engineering/caching-without-marshal-part-two-messagepack>)

Author: Chris Salzberg

Published: 2022-11-15T15:00:00Z

Content type: article

Language: en

Sources: [Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering.md>), [Shopify Engineering - Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering-shopify-engineering.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Rails](<https://devfeed.tech/topics/rails.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [code](<https://devfeed.tech/tags/code.md>), [rails](<https://devfeed.tech/tags/rails.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [serialization](<https://devfeed.tech/tags/serialization.md>), [serialization-format](<https://devfeed.tech/tags/serialization-format.md>)

### AI overview

Shopify's second article on replacing Ruby's Marshal cache format explains how MessagePack provides a more robust binary serialization format for Rails caching. Unlike Marshal, MessagePack is language-independent and avoids encoding Ruby-specific types that can make cached data fail after code changes.

### Source excerpt

Shopify wanted a cache format that would not blow up when we shipped code changes. Part two of Caching Without Marshal describes the MessagePack format, and how we migrated to MessagePack.