> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rhetoric.law/llms.txt
> Use this file to discover all available pages before exploring further.

# The filing lifecycle

Filings go through several stages, and pass through several hands, before they
land on the case docket or get sent back. This page describes that sequence.

## Assembly

Before anything is transmitted, the filer (or their EFSP) assembles the
envelope: the document itself, the case it belongs to, the parties, and the
filing type. For a new case, the filer also chooses a **case type** (for
example, "breach of contract"). This designation determines what happens next
and which court department the case is routed to. For an existing case, the
filer references the case number instead.

## Transmission

The EFSP transmits the envelope to the court's EFM. This is a machine-to-machine
call; the filer does not interact with the court's systems directly. At this
point the filing has a transmission timestamp, but it is **not yet part of the
official record**. Many jurisdictions distinguish between the time a filing was
*submitted* and the time it was *accepted*; some treat the submission time as
the effective filing date (useful for beating a deadline), while others use the
acceptance time.

If the filing carries a court fee, this is also when payment is charged;
submission and payment are treated as a single transaction, so a failed charge
means the filing is not transmitted. See [Filing fees](/guides/primer/fees) for
more information about fees.

Until the court reviews the envelope, it can typically be canceled and the
fees refunded.

## Review

A court clerk reviews the envelope. This step checks things a machine can verify
only partially:

* Is this the correct document for this case and filing type?
* Are the parties named correctly, and is the caption right?
* Does the filing meet local formatting rules (page limits, redaction
  requirements, and so on)?
* Have the correct fees been included?

This review can result in a few outcomes:

<Steps>
  <Step title="Accepted">
    The filing is approved and becomes part of the official case record. It is
    assigned a filed date and time and, for a new case, a case number.
  </Step>

  <Step title="Rejected">
    The filing is refused outright. The filer receives a reason and must submit
    a new envelope if they still want to file.
  </Step>

  <Step title="Correction requested">
    Some courts allow a middle ground: the clerk flags a specific, minor issue
    (like a missing signature block) and lets the filer fix and resubmit without
    starting over.
  </Step>
</Steps>

Review is not immediate. Depending on the court and time of day, it can take
anywhere from minutes to a day or more. This is why efiling systems are built
around asynchronous status updates rather than a single synchronous "yes" or
"no" at submission time.

## Docketing

Once accepted, the filing is docketed: it is formally entered into the court's
case management system and becomes part of the case's official chronological
record. For a new case, this is also when a case number is typically assigned.
From this point on, the filing is a permanent part of the case, visible to the
court, the parties, and (depending on the jurisdiction's public access rules)
potentially the public.

## Notification

Interested parties are notified that a filing occurred. Depending on the
jurisdiction and case type, this can happen automatically as part of efiling
(electronic service) or may require the filer to separately serve other parties.
For more information on service, see [Service of
process](/guides/primer/service).

## Checking status

Because review is not instant, efiling systems generally support checking on a
filing after submission rather than only relying on being told the moment
something changes. In practice, most integrations use a combination of both: an
asynchronous notification when a court finishes review, plus the ability to
explicitly check current status, since notifications can be delayed or missed.
The status of a filing over its lifetime typically looks like:

`submitting → submitted → under review → accepted` (or `rejected`)

There may be additional intermediate states depending on the court, e.g.,
`receipted` (acknowledged but not yet reviewed), `deferred`, or `correction`
(sent back for a fix).