How to register without friction

Onboarding is designed to be short and safe. The sequence is fixed so identity and organization data are verified from day one.

1. Step 1 - Email: enter a valid admin email.
2. Step 2 - OTP validation: confirm the one-time code sent to that email.
3. Step 3 - Company profile: add company details, admin name, and password.

After submission, the organization enters PENDING_APPROVAL. You get access after validation.

Welcome inside: what to set first

In Dashboard -> Settings, owners configure how the team works every day.

• SLA policy: sets response and processing targets for new claims.
• Claim tags policy: defines required tags and order for classification.
• Appearance: logo and color identity for client-facing communication (plan dependent).
• API keys: owner-level keys for secure integrations.
• Language: workspace language for daily use.

Roles and why each one matters

Roles are there to keep decisions clear and prevent accidental misuse.

Complaint journey, end-to-end

This is the operational route each complaint follows.

Actions that move a complaint forward

Actions are intentionally sequenced. You do not skip steps.

• Pick up claim: moves NEW to IN_PROGRESS.
• Submit for approval: from IN_PROGRESS to WAITING_FOR_APPROVAL.
• Approve and send to client: to WAITING_CLIENT_SIGNATURE.
• Client confirmation: system transition to PROCESSING_SOLUTION.
• Finalize: from PROCESSING_SOLUTION to SOLVED.

Features your team uses every day

These are the features teams use most often to keep the complaint pipeline healthy.

• Logo + color identity: branded communication for client-facing moments.
• AI text refining: short message refinement for clearer client updates.
• Twilio SMS: faster client reach for confirmation and follow-up.
• Resend email: structured and traceable delivery to client and team.
• Audit trail: critical actions remain visible for accountability.
• Usage controls: plan limits + add-ons managed from HQ.

Turn long complaint threads into clear tasks

Tasks turn long complaint threads into concrete next actions.

• Tasks support content, due date, assignee, and complaint link.
• Owners/Admins can delegate. Non-delegating users assign to themselves.
• Tasks are blocked while complaint is still NEW (triage lock).
• When someone is suspended/deleted, open tasks are reassigned for continuity.

Comments and mentions without noise

Comments are split by communication purpose.

• Normal comment: team-visible operational discussion.
• Internal note: restricted internal note.
• Client message: external communication to client channels.

Mention rules (plain language)

• Mentions are not allowed in CLIENT_MESSAGE.
• You cannot mention yourself.
• You can mention only teammates who can already see the complaint and that message type.
• Internal note mentions are stricter than normal comments.

SLA timers: what to set and why it matters

SLA is your timing policy. It gives every phase a clear target.

Simple example

If first response SLA is 2h and a claim is created at 10:00, pickup should happen by 12:00 to stay healthy.

Tags and their real impact on SLA

Tags are more than labels. They drive classification quality and can influence proposal preparation timing.

• ISSUE_TYPE can define a base number of hours.
• SEVERITY can multiply timing pressure (for example 150%).
• CAUSE can add complexity bonus (for example +20%).
• SEGMENT is for reporting and does not change SLA.

Clear numeric example

Base hours from issue type = 8h, severity factor = 150%, complexity bonus = 20%. Final target = ceil(8 x 1.5 x 1.2) = 15h.

Coverage transfer that prevents blocked operations

Use coverage transfer when a teammate is unavailable (planned leave or sudden absence) so active work keeps moving without SLA disruption.

1. Owner/Admin selects source member and backup member.
2. Choose immediate transfer or scheduled coverage window.
3. For scheduled coverage, backup accepts before start time.
4. At activation, active operational ownership and open tasks move to backup.
5. At coverage end, ownership rules apply automatically based on proposal state.

• Personal notes remain personal and are never transferred.
• Transferred claims are marked subtly for backup visibility.
• CSAT ownership stays consistent with proposal ownership rules.

API docs inside the same roadmap

The API lane is for teams that want to import complaints from external websites or apps.

Endpoint family in scope: POST https://app.solve.claims/api/v1/ingest.

Generate your API key (Owner only)

1. Log in to app.solve.claims with an Owner account.
2. Open Dashboard -> Settings -> API Keys.
3. Create a key and copy it immediately (shown once).

Endpoint and payload

Endpoint: POST https://app.solve.claims/api/v1/ingest

Headers:

Content-Type: application/json
x-api-key: sc_live_...

Body sample:

{
  "clientName": "Jane Doe",
  "clientEmail": "jane@example.com",
  "clientPhone": "+40 700 000 000",
  "reference": "ORDER-1001",
  "description": "Complaint details",
  "files": [
    {
      "name": "invoice.pdf",
      "type": "application/pdf",
      "size": 245760
    }
  ]
}

• Allowed file types: image/jpeg, image/png, image/webp, application/pdf
• Limit: max 8 files/complaint, max 10MB/file
• Rate limit: endpoint may return 429 Too Many Requests; respect Retry-After
• Policy: video files are blocked on API ingest

2-step upload flow

1. Call ingest with complaint fields and file metadata.
2. Receive complaintId + uploads[] signed URLs.
3. Upload each real file with PUT to the signed URLs.

{
  "success": true,
  "complaintId": "cm123...",
  "uploads": [
    {
      "fileName": "invoice.pdf",
      "fileType": "application/pdf",
      "uploadUrl": "https://...signed-url..."
    }
  ]
}

Security requirements and storage cost notes

• Use a backend relay endpoint (Node/PHP/Python/WordPress app).
• Whitelist allowed origins via INGEST_ALLOWED_ORIGINS.
• Restrict file types in both UI and backend before sending.
• Keep retries controlled when 429 is returned.

Attachment scan lifecycle

• PENDING: scan running, download blocked.
• CLEAN: download allowed.
• MALICIOUS: quarantined.
• FAILED: blocked until resolved.

Simple S3 estimate model

stored_gb = complaints_per_month * avg_files_per_complaint * avg_file_size_mb / 1024
storage_cost = stored_gb * storage_rate_per_gb
put_cost = (total_upload_requests / 1000) * put_rate
get_cost = (total_download_requests / 1000) * get_rate

Snippets

import express from "express";
import fetch from "node-fetch";

const app = express();
app.use(express.json({ limit: "2mb" }));

app.post("/api/complaints/submit", async (req, res) => {
  const payload = {
    clientName: req.body.clientName,
    clientEmail: req.body.clientEmail || "",
    clientPhone: req.body.clientPhone || "",
    reference: req.body.reference || "",
    description: req.body.description,
    files: req.body.files || []
  };

  const ingestResponse = await fetch("https://app.solve.claims/api/v1/ingest", {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-api-key": process.env.SOLVECLAIMS_API_KEY
    },
    body: JSON.stringify(payload)
  });

  const ingestData = await ingestResponse.json();
  if (!ingestResponse.ok) {
    return res.status(ingestResponse.status).json(ingestData);
  }

  return res.json(ingestData);
});

add_action('admin_post_nopriv_sc_submit_complaint', 'sc_submit_complaint');
add_action('admin_post_sc_submit_complaint', 'sc_submit_complaint');

function sc_submit_complaint() {
  $payload = array(
    'clientName' => sanitize_text_field($_POST['clientName'] ?? ''),
    'clientEmail' => sanitize_email($_POST['clientEmail'] ?? ''),
    'reference' => sanitize_text_field($_POST['reference'] ?? ''),
    'description' => sanitize_textarea_field($_POST['description'] ?? ''),
    'files' => array(),
  );

  $response = wp_remote_post('https://app.solve.claims/api/v1/ingest', array(
    'headers' => array(
      'Content-Type' => 'application/json',
      'x-api-key' => getenv('SOLVECLAIMS_API_KEY'),
    ),
    'body' => wp_json_encode($payload),
    'timeout' => 20,
  ));

  wp_redirect(home_url('/complaint-thank-you/'));
  exit;
}

<?php
$payload = [
  "clientName" => $_POST["clientName"],
  "clientEmail" => $_POST["clientEmail"] ?? "",
  "reference" => $_POST["reference"] ?? "",
  "description" => $_POST["description"],
  "files" => []
];

$ch = curl_init("https://app.solve.claims/api/v1/ingest");
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  "Content-Type: application/json",
  "x-api-key: " . getenv("SOLVECLAIMS_API_KEY")
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
?>

API FAQ

Can we send directly from browser to ingest?

Technically yes, but that exposes your API key. Production best practice is always server-side relay.

Can end users upload any file type?

No. Policy allows only JPEG, PNG, WEBP, and PDF in ingest.

Where imported complaints appear?

They appear in Dashboard -> Claims with NEW status and enter normal workflow.