Engineering. reusable systems.
/// ENGINEERING_MEMORY Tunet Engineering turns repeated technical work into shared capability: open-source contracts where portability matters, commercial tools where teams need speed, support, and operational ownership.
The point is simple: the same engineering memory should not be rebuilt in every product. If a pattern can stand alone, we open it. If it needs a service surface, we operate it.
One engineering memory, two ways to use it.
Engineering starts when a hidden piece of product work appears often enough to deserve a name, a contract, tests, docs, and a path out of one-off glue code.
Some pieces should be inspectable and portable, so they become Open Source. Others need support, hosting, onboarding, or service ownership, so they become Commercial Tools.
Find the recurring edge
We look for glue code, data shapes, provider seams, safety checks, and migration paths that keep reappearing.
Make behavior explicit
The useful parts should be inspectable: inputs, outputs, failure modes, defaults, migrations, and escape hatches.
Ship tests and examples
A framework needs examples, boundaries, tests, release notes, and a reason another developer should care.
Publish what can stand alone
The pieces that solve a general developer problem become packages, docs, reference implementations, and public examples.
Engineering catalogue
Open Source and Commercial Tools together.
Search the engineering catalogue or switch between the two useful families: Open Source foundations and Commercial Tools. The card details carry the finer technical context.
Product foundations
Portable contracts and canonical data that help products travel further.
Trust foundations
Explicit security and access layers for products that need to earn confidence.
SwapLayer
Framework-neutral provider contracts for billing, communication, storage, and identity, with Django/FastAPI adapters and an MCP server.
Core contract
Provider adapters
Product effect
Migration freedom
GeoCanon
Typed Django locale data for jurisdictions, ISO codes, currencies, addresses, phones, timezones, languages, and holidays.
Core contract
Canonical market data
Product effect
Global consistency
SessionArmor
Security-focused Django middleware for session continuity signals, timeouts, privacy-aware audit events, and revocable request gates.
Core contract
Session security gates
Product effect
Traceable access
AccessGate
A data access layer for permissions, policy enforcement, row-level filtering, encryption posture, and auditable access decisions.
Core contract
Policy decisions
Product effect
Least privilege
Commercial Tools / Interface systems
Supported UI foundations for faster, more consistent product delivery.
Commercial Tools / Managed infrastructure
Operated technical services that remove recurring backend work.
AZ Super UI Kit
A practical component system for teams that need consistent UX, accessibility defaults, and faster launch velocity without rebuilding every interface pattern.
Technical surface
Product interfaces
Team effect
Faster consistent UI
Database as a Service
A managed relational database layer for teams that want secure provisioning, isolation, realtime subscriptions, policy controls, and a clearer backend starting point.
Technical surface
Managed backend
Team effect
Operational confidence
No Engineering entries match that filter yet.
Engineering standard
What makes a Tunet Engineering piece worth shipping.
Whether it is open-source or commercial, the layer has to be legible, portable, tested, and useful without needing the whole Tunet stack around it.
Portable by default
Data, configuration, and contracts should move cleanly between products, teams, and vendors.
Proven in real apps
The pattern should come from lived product pressure, not abstract architecture taste.
Documented boundaries
Developers should understand what the layer owns, what it refuses to own, and how to escape it.
Release discipline
Versioning, deprecations, examples, tests, and support windows matter as much as the first implementation.
Engineering planning guide
Choose the right first layer.
Most technical drag hides inside glue code, implicit defaults, and provider decisions nobody wants to own. Tunet Engineering makes those behaviours explicit so teams can reason, review, migrate, and reuse safely.
Start with SwapLayer if
- You rely on one payment, email, storage, or auth provider.
- You need a controlled migration path between vendors.
- You want consistent errors across integrations.
Start with GeoCanon if
- Your product operates across countries or jurisdictions.
- Locale, phone, timezone, or holiday data is duplicated.
- Compliance and localization logic keeps drifting.
Start with SessionArmor if
- You need stronger Django session security.
- Audit logging is part of your compliance story.
- You need hookable gates for onboarding or policy checks.
Use Commercial Tools if
- You need a supported UI system or managed backend.
- The problem needs service ownership, not just source code.
- Adoption speed matters more than assembling every layer yourself.
What a candidate should prove in the first 30 days
Weeks 1 to 2
Extract the layer in a low-risk path, validate its contracts, and decide whether it should be open, supported, or both.
Weeks 3 to 4
Move one real workflow end to end, add CI contract tests, and package the adoption path with examples, docs, or service onboarding.
Found a pattern that should stop being rebuilt?
Bring the repeated engineering pain: the integration, schema, security layer, UI system, backend service, evaluation loop, or workflow contract that keeps reappearing.