Matrix-compatible E2EE
Message content is encrypted between participating clients with matrix-sdk-crypto.
Early Access
September 2026 · Up to 5 organizations
Secure private real-time messaging, Matrix-compatible and built to scale.
Neurons is an integrated messaging platform deployed in your AWS account. It keeps message content end-to-end encrypted, scales elastically with demand, federates with Matrix homeservers, and delivers updates through real-time push events.
Web client + serverless backend
Deployed in your AWS account
Extensible for domain products
Elastic serverless scale
Scale from idle with demand without pre-provisioning an always-on server fleet.
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 planning a fixed homeserver fleet in advance.
Real‑time push delivery
AppSync Events delivers updates over WebSockets instead of maintaining a traditional long-polling client sync loop.
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 Matrix server-server compatibility so rooms and messages can move across organizational boundaries with Synapse and other homeservers. The Neurons web client provides Matrix-compatible E2EE while using push-based sync instead of Matrix long-polling.
AWS serverless scale
Elastic capacity without an always-on server fleet.
Neurons runs on managed AWS services that respond to workload rather than a fixed homeserver footprint. Lambda, AppSync Events, and DynamoDB remove the need to size and operate a traditional messaging server fleet in advance.
The architecture can scale from idle to high demand within configured AWS quotas and workload limits, while push delivery keeps the client experience reactive.
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.
Is Neurons fully Matrix-compatible?
Neurons focuses on Matrix server-server compatibility for federation. The client-server API is not a full drop-in Matrix implementation because sync is handled through a websocket-based real-time channel.
Can we use Element or another Matrix client?
The current product is designed to work with the Neurons web client because its sync model differs from the standard Matrix long-polling endpoint.
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 content. E2EE protects content between clients;
endpoint security, identity, and metadata remain separate security responsibilities.
How does Neurons scale?
Serverless components respond to workload within configured AWS quotas and deployment limits. Neurons avoids pre-provisioning a traditional homeserver fleet, but 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.