When you build an education network, backend is not just infrastructure —
it’s the foundation of trust, speed, and reliability.
From day one, we knew Hischool had to support:
- realtime collaboration
- thousands of concurrent users
- messages, files, media
- schools, programs, cohorts
- and everything happening at the same time
So we made one clear decision early:
We will build the backend for performance, stability, and long-term scale — not convenience.
Why microservices from the start
Hischool is not a simple app.
It’s a network of schools, people, and interactions.
So we designed the backend as independent microservices, each with a clear responsibility:
- easier to reason about
- easier to scale
- easier to secure
- easier to evolve
Each service can grow without breaking others.
Why Rust (and why not Node.js or Java)
Before Hischool, we used:
- Node.js
- Java
- traditional frameworks
They worked — but not for what we needed.
We wanted:
- minimal memory footprint
- predictable performance
- true concurrency
- no runtime surprises
- zero-cost abstractions
After research and multiple experiments, the answer was clear:
Rust gives us performance close to C, safety close to nothing else, and confidence in production.
And for the web framework — we chose Actix:
- blazing fast
- async-first
- battle-tested
- perfect for microservices
Our backend architecture
Every core function lives in its own microservice — all built with Rust + Actix.
Auth microservice
Handles:
- user registration
- login
- authentication
- password management
- verification
- security rules
It is isolated by design, because auth is sacred.
Realtime microservice (WebSocket server)
This service connects frontend and backend without delay.
It powers:
- live messages
- presence
- typing indicators
- realtime updates
- collaboration
When something happens, everyone sees it instantly.
Storage microservice
Handles:
- user avatars
- school covers
- chat media
- files
- uploads
We use:
- AWS S3 for dynamic files (media, uploads)
- local filesystem for static assets (emoji, icons, system images)
This gives us:
- speed
- control
- flexibility
- lower cost
Proxy microservice
Solves:
- image optimization
- media delivery
- embed previews
- link rendering
- external content handling
It protects the core system while making content look good everywhere.
API microservice
This is the brain of the system.
It manages:
- schools
- groups
- calendar events
- online courses
- roles
- permissions
- messages
- threads
- analytics
- business logic
Everything connects here — cleanly and safely.
Designed for minimal footprint, maximum speed
From the beginning, our goal was:
Small memory, fast execution, no waste
Rust + Actix allows us to:
- run more users per server
- reduce infrastructure cost
- stay predictable under load
- sleep well at night
No garbage collection pauses.
No hidden slowdowns.
No runtime surprises.
One backend, many clients
This backend powers:
- Web (PWA)
- Android
- iOS
- Desktop
All clients talk to the same backend.
All benefit from the same improvements.
All get updates instantly.
What’s next
We’re working on:
- better caching strategies
- smarter realtime fanout
- background jobs
- distributed tracing
- auto-scaling policies
- even faster startup times
But the foundation is already there.
Built with intention
We didn’t choose Rust and microservices because it’s trendy.
We chose it because:
- education deserves reliability
- communities deserve speed
- creators deserve trust
- and the future deserves a solid foundation
This backend is built to last.
And we’re just getting started.