Every query has an owner,
a clock, and a record.
Corvessa is an issue tracking and client query management system that runs inside your organisation. Never a tenant on a shared platform: you maintain your own database, your infrastructure, your retention rules, and your audit trail.
- 09:14 issue.created · channel=whatsapp
- 09:15 issue.assigned · team=client_services
- 09:31 severity.changed · moderate → major
- 10:02 escalation.raised · to=finance_ops
- 11:48 issue.resolved · sla=met
A system is defined by what it refuses to do.
Feature lists are easy to match. The difference between a tracker that survives an audit and one that quietly costs you a client sits in six architectural guarantees designed before the first database table was created, never patched in after an incident.
An internal note never becomes client-visible
Visibility is an explicit property of every comment, enforced server-side at write and at read. There is no shared field, no display flag that can be flipped by a template change, and no export path that collapses the two.
A failed notification never blocks a resolution
Email and WhatsApp are optional integrations behind a common abstraction. If a provider is down, misconfigured, or switched off entirely, the issue still moves. The failure is logged and auditable; the transaction is not rolled back.
A configuration change never rewrites history
Rename a category, retire a queue, or restructure a department without breaking history. Issues closed last year continue to read exactly as they were recorded, preserving point-in-time business values instead of dynamically resolving them from current settings.
An attachment is never a public URL
Files sit behind the application's storage abstraction, never in a web-served directory. Every download is authorised against the requesting user and the specific issue, and every download is recorded.
Authorisation never happens only in the browser
Hidden buttons are a courtesy, not a control. Every mutation passes a server-side policy check regardless of what the interface offered, and the database identifiers behind an issue are never the reference a user sees.
An operational record is never silently deleted
Issues, comments, and audit entries are not hard-deleted through the application. Audit rows are immutable once written. When something must be removed for a legal reason, it is a documented administrative act with its own trail.
Priority is urgency. Severity is impact. They are not the same field.
Most trackers collapse the two into one dropdown, and every desk that uses one eventually learns the cost: a cosmetic fault screaming for attention while a quiet reconciliation error compounds. Corvessa keeps the axes apart, because they route differently.
Urgent · Critical
Select a cell to see how Corvessa treats that combination.
Escalation is not a status.
The moment escalation becomes a stage in the lifecycle, you lose the ability to say what is actually happening to the work. An escalated issue is still in progress, or still pending a client response. Corvessa runs escalation as a parallel concern that coexists with status so every report answers both dimensions independently.
Seventeen domains, one application.
Corvessa is a modular monolith with clear domain boundaries inside a single deployable application. You get zero service meshes to operate, no distributed transactions to reason about at midnight, and no unnecessary orchestration layer between your team and your data.
Notifications degrade. The desk does not.
Switch a channel off and watch what happens to the issue. Nothing. That is the design. Try it.
The audit trail is not a log file. It is the reason the system exists.
When a regulator, an internal auditor, or a client's lawyer asks what happened on a particular account in March, the answer should take a query, not an archaeology project.
What is recorded
- 01
Actor, action, entity
Who performed the action, what was modified, and which record was affected, captured alongside verified session and network metadata.
- 02
Old value and new value
Not just that severity changed, but from what to what. Priority, assignment, status, escalation, and client details all carry before-and-after.
- 03
Security and access events
Authentication, permission updates, role modifications, and integration configurations: the foundational events that govern access.
- 04
Timestamps you can defend
Stored consistently, displayed in the organisation's configured timezone. A record does not shift because a server moved.
What reporting answers
- 01
Where work is stuck
Real-time ageing by queue, team, assignee, and client. Not a vanity dashboard, but an actionable agenda of items requiring resolution.
- 02
Whether SLAs held
Response and resolution against target, with breaches broken out by cause rather than aggregated into a single percentage.
- 03
What clients keep raising
Query volumes and repeat rates segmented by category, type, and channel, providing the data needed to fix root causes rather than just closing tickets.
- 04
Exports that reconcile
Reports are built in a dedicated query layer, filtered and paginated server-side, so a spreadsheet pulled today matches the screen it came from.
Built industry-neutral, configured per organisation.
Categories, types, teams, SLA targets, and escalation paths are configuration, not code. The same deployment serves a claims desk and a municipal billing office without either inheriting the other's vocabulary.
Insurance
Claims queries, policy disputes, broker escalations with evidence attached.
Banking and microfinance
Transaction disputes and reconciliation queries where the audit trail is the deliverable.
Retail
Returns, warranty claims, and branch-level complaints routed to the team that owns the outcome.
Professional services
Client requests across engagements, with internal deliberation kept firmly off the client record.
Utilities
High-volume fault and billing queries with severity that reflects service impact, not caller volume.
Public sector
Citizen queries where retention rules and non-deletion are statutory rather than preferences.
Your infrastructure. Your data. Your call on every upgrade.
Corvessa is not sold as a shared subscription on multi-tenant servers. It is deployed directly into your own infrastructure (on-premise or private cloud) and remains entirely under your custody. No shared databases, no cross-organisation indexes, and no third parties holding the keys to your client records.
How an implementation runs
- 01
Discovery
We map your existing queues, categories, ownership hierarchies, and escalation paths as they function day to day, capturing undocumented institutional workflows.
- 02
Configuration
Teams, SLA targets, comment visibility rules, and role permissions are configured and reviewed with the people who will live inside them.
- 03
Pilot desk
One team runs live on Corvessa while the old process continues in parallel. Nothing migrates until the pilot desk stops finding surprises.
- 04
Rollout and handover
Remaining teams onboard in sequence. Your administrators are trained on configuration, audit review, and integration management before we step back.
What the deployment includes
- 01
Queue workers and scheduled tasks
SLA clocks, escalation checks, and notification dispatch run asynchronously so the interface stays fast under load.
- 02
Encrypted integration credentials
SMTP and WhatsApp credentials are stored securely, never returned in API responses, and never written to logs.
- 03
Automated test coverage
Authorisation, validation, state transitions, and failure handling are covered by tests that ship with the release, not by manual sign-off.
- 04
Documented upgrade path
You decide when to take a release. Migrations are reversible where the data allows and always reviewed against your configuration first.
See it against your worst week.
Bring the queries that went wrong: the one where an internal note leaked to a client, the query nobody could prove was answered, or the ticket that sat unattended for two weeks. We will demonstrate how Corvessa resolves each scenario live on an active deployment, not a static slide deck.