Yes — for event-driven apps that need low-latency writes plus JSON/document support, you’ll usually want a multi-model or hybrid database service that can handle:

• fast ingest / append-heavy workloads
• JSON document storage and querying
• easy event processing / change feeds / triggers
• scalable managed operations

Here are solid options:

1. Azure Cosmos DB

Best for: globally distributed, low-latency event-driven apps

• Supports document JSON natively
• Very low write latency with automatic scaling
• Change Feed is excellent for event-driven architectures
• Multiple APIs: SQL (Core), MongoDB, Cassandra, Gremlin, Table
• Strong managed service with global distribution

Why it fits:
If you need fast writes and event processing, Cosmos DB’s Change Feed is a major advantage for building pipelines, projections, or reactive services.

Watch for:

• Cost can grow quickly with high throughput
• Query model and RU/s tuning require some care

---

2. Amazon DynamoDB + PartiQL / DynamoDB Streams

Best for: highly scalable low-latency event ingestion on AWS

• Extremely fast key-value / document-style writes
• JSON-like items with flexible schema
• DynamoDB Streams supports event-driven integrations
• TTL, transactions, global tables for multi-region
• PartiQL adds SQL-like access

Why it fits:
Great if your event model is mostly keyed access and you want very high write throughput with minimal ops.

Watch for:

• Not a full multi-model database in the traditional sense
• Complex ad hoc querying is limited compared to document databases

---

3. MongoDB Atlas

Best for: JSON-heavy event applications needing flexible querying

• Native BSON/JSON document model
• Good write performance, especially with proper shard design
• Change Streams support event-driven processing
• Flexible schema for evolving event payloads
• Atlas is fully managed

Why it fits:
If your events have rich nested JSON and you need expressive querying, MongoDB Atlas is a strong choice.

Watch for:

• Multi-region latency and very high write scaling need careful architecture
• Operational tuning matters more than DynamoDB/Cosmos for extreme throughput

---

4. Couchbase Capella

Best for: low-latency operational apps with JSON and cache-like performance

• JSON document database with very fast reads/writes
• Eventing service built in
• SQL++ query language for documents and analytics
• Good fit for edge and interactive event-driven systems

Why it fits:
Couchbase is often strong when you want both document flexibility and very low latency.

Watch for:

• Query/index design still matters a lot
• Smaller ecosystem than AWS/Azure/MongoDB

---

5. Google Cloud Firestore

Best for: simple event-driven apps with real-time sync

• JSON-like document model
• Very low-latency writes for many app patterns
• Real-time listeners are useful for reactive systems
• Fully managed on GCP

Why it fits:
Excellent for apps that need real-time client updates and straightforward document storage.

Watch for:

• Limited querying compared to MongoDB/Cosmos
• Not ideal for advanced multi-model needs

---

6. ArangoDB Oasis

Best for: true multi-model needs in one service

• Supports document, graph, and key-value in one engine
• JSON document support
• Good for systems where event data also needs relationships/graph traversal
• Managed service available as Oasis

Why it fits:
If your event-driven app also needs graph-like relationships or flexible multi-model access, ArangoDB is worth looking at.

Watch for:

• Less mainstream than Cosmos/MongoDB/DynamoDB
• Smaller managed-service ecosystem

---

Quick recommendations by scenario

If you want the safest cloud-managed option for event-driven architectures:

• Azure Cosmos DB
  Best mix of low-latency writes + change feed + JSON + global distribution

If you’re on AWS and want maximum write throughput:

• DynamoDB + Streams

If you want flexible JSON querying and event streams:

• MongoDB Atlas

If you want one service with document + graph + key-value:

• ArangoDB Oasis

If you want very low-latency document storage with built-in eventing:

• Couchbase Capella

---

What to prioritize when choosing

For event-driven apps, check these features:

• Write latency under load
• Change data capture / streams / triggers
• Native JSON document support
• Horizontal scaling
• Global replication / multi-region support
• Indexing and query flexibility
• Cost predictability

---

Short shortlist

If I had to narrow it to 3:

1. Azure Cosmos DB — best all-around for event-driven + JSON + low latency
2. DynamoDB — best for extreme scale and simple access patterns
3. MongoDB Atlas — best for flexible JSON queries and developer experience

If you want, I can also give you:

• a feature comparison table
• recommendations by cloud provider
• or a shortlist based on your expected write volume / latency target / query patterns