End-to-end encrypted content
Messages and attachments are encrypted between participating clients with matrix-sdk-crypto.
Early Access
September 2026 · Up to 5 organizations
Secure end-to-end encrypted messaging, Matrix-compatible and built to scale.
Neurons is an integrated real-time messaging platform deployed on serverless AWS in your account. It encrypts messages and attachments between participating clients, scales elastically with demand, federates with Matrix homeservers, and delivers updates through real-time push events.
E2EE messages + attachments
Matrix server-server federation
Elastic AWS serverless scale
Elastic serverless scale
Scale from idle with demand without reserving compute capacity for quiet periods.
Real-time push delivery
WebSocket events replace long-polling
/sync for the Neurons web client.
Matrix federation
Rooms and messages interoperate through the Matrix server-server API.
Platform
Five reasons to choose Neurons.
Neurons combines content privacy, elastic operation, immediate delivery, open interoperability, and customer control in one deployable communication product.
Privacy by design
Message content remains end-to-end encrypted between participating clients using Matrix-compatible cryptography.
Elastic serverless scale
Lambda, DynamoDB, and managed AWS services respond to workload without estimating a fixed runtime footprint before demand arrives.
Real‑time push delivery
AppSync Events delivers updates over WebSockets instead of maintaining the traditional
long-polling /sync channel, while client operations retain Matrix-native
contracts and event formats.
Matrix interoperability
Server-server compatibility lets rooms and messages federate with Synapse and other Matrix homeservers.
Customer‑owned AWS
Runtime components and data stores run in a dedicated customer AWS account for clearer control, isolation, and operational ownership.
Privacy
End-to-end encryption is part of the product, not an add-on.
The Neurons web client uses matrix-sdk-crypto for Matrix-compatible E2EE.
Message content and attachments stay encrypted between participating clients, including
when rooms cross organizational boundaries through federation.
Client-side cryptography
Encryption and decryption happen at participating clients rather than in the serverless messaging core.
Federated protection
Matrix-compatible encrypted content remains protected as events move between Neurons, Synapse, and participating Matrix clients.
A clear security boundary
E2EE protects message content and attachments. Endpoint security, identity, metadata, and access governance remain explicit parts of each deployment's security model.
Matrix interoperability
Connect to the Matrix ecosystem through federation.
Neurons implements the standard Matrix server-server API directly, so rooms and messages
can move across organizational boundaries with Synapse and other homeservers without
protocol conversion. Implemented client operations use standard Matrix client-server
contracts and event formats; only synchronization moves from long-polling /sync
to AppSync Events WebSocket push, which requires the Neurons web client.
AWS serverless scale
Elastic capacity that follows demand.
Neurons runs on managed AWS services that respond to workload instead of relying on permanently provisioned compute. Lambda, AppSync Events, and DynamoDB avoid sizing peak capacity in advance and maintaining a traditional messaging runtime around the clock.
The architecture can scale from idle to high demand within configured AWS quotas and workload limits, while push delivery keeps the client experience reactive.
See the technical architecture
Extensibility
Build domain products on a secure communication backbone.
Neurons provides the secure communication backbone for domain products that combine encrypted messaging, federation, identity, directories, policy, and workflows. For example, a TI-Messenger-style healthcare product could be built on Neurons, using its AWS serverless backend as an alternative foundation to Synapse Pro. Meeting the applicable TI-Messenger specifications and approval requirements would remain part of the domain product.
Beyond chat
Messaging as a platform layer.
Use Neurons as the foundation for specialized clients, role-specific experiences, directories, integrations, policy layers, and federated communication networks while retaining E2EE, real-time delivery, and elastic AWS infrastructure.
Built by devFlorence
Engineered by a senior-led software development studio.
Neurons is designed and developed by devFlorence, an independent software development studio focused on senior engineering ownership, modern Java, AWS-native infrastructure, and production discipline.
Studio behind Neurons
Built with direct senior engineering ownership.
devFlorence is led by Alessandro De Stasio and combines 30+ years of software engineering experience with modern Java, AWS-native infrastructure, and AI-assisted delivery under senior technical control.
30+ years software engineering
28 years Java stack
1:1 senior ownership
Visit devFlorence
Neurons Early Access Program · Applications open
Evaluate Neurons in your AWS environment.
First evaluations begin in September 2026. Up to five organizations will be selected for the initial cohort and receive a paid, fixed-scope technical evaluation of product fit, deployment and interoperability.
Best fit
- Organizations that need private, encrypted real-time communication.
- Teams using or evaluating Matrix, Synapse or Element interoperability.
- Teams with data-control, compliance, sovereignty or customer-hosted infrastructure requirements.
- Software companies, integrators and regulated service providers building communication products.
Evaluation structure
- A 4-6 week technical evaluation with agreed success criteria.
- One non-production deployment in your AWS account.
- E2EE, workload scaling, Matrix federation and real-time push validation.
- Direct support from the senior technical owner.
Early access benefits
- The evaluation fee is credited if you move to production.
- Preferential first-year subscription terms and second-year price protection.
- Completed deployment work is reused instead of charged again.
- Feedback is considered for the product roadmap; customer-specific work is quoted separately.
FAQ
Questions before applying.
Short answers to the technical and deployment questions that usually decide whether an early access evaluation is worth scheduling.
Is Neurons a Synapse alternative?
Yes. Neurons is positioned as a serverless, AWS-native alternative to operating a traditional Synapse-style Matrix homeserver stack. Read the serverless Matrix technical guide for the operating model and compatibility boundaries.
How does Neurons use the Matrix APIs?
Implemented client operations use standard Matrix client-server contracts and event
formats. Neurons replaces only the long-polling /sync channel with AppSync
Events WebSocket push. Federation independently uses the standard Matrix server-server
API, directly and without protocol conversion.
Can we use Element or another Matrix client?
The current product requires the Neurons web client because Element and other standard
clients expect the HTTP long-polling /sync channel. Neurons delivers
synchronization updates through AppSync Events WebSocket push instead.
Where is customer data hosted?
The intended deployment model is customer-hosted: runtime services and data stores run inside the customer AWS account.
Does Neurons support end-to-end encryption?
The Neurons web client relies on matrix-sdk-crypto for Matrix-compatible
end-to-end encryption for messages and attachments. E2EE protects content between
clients; endpoint security, identity, and metadata remain separate security
responsibilities. The E2EE guide
describes that boundary in detail.
How does Neurons scale?
Serverless components respond to workload within configured AWS quotas and deployment limits. Neurons does not reserve baseline application capacity before demand arrives, but it does not claim unbounded capacity.
Who is the Early Access Program for?
Organizations evaluating private encrypted messaging, elastic customer-hosted AWS deployment, Matrix federation, or domain products built on a secure real-time communication backbone. First evaluations begin in September 2026 and the initial cohort is limited to five organizations.
Applications open · September 2026
Apply to the Neurons Early Access Program
We are selecting up to five organizations for the initial cohort. Tell us enough to understand your use case, expected scale and deployment context. If there is a fit, the next step is a technical discovery call.