Getting started

Gravitas is a cloud-native ETRM/CTRM platform that runs the full commodity trade lifecycle on one governed data model. Before diving into configuration, it helps to see how a trade moves through the platform end to end, because that single flow is the mental model everything else hangs from.

A first session needs three things in place. Each is a one-time setup that the rest of your work builds on.

• Access: a login for the UI, and, for programmatic work, a client credential (see Authentication).
• Reference data: at least one commodity, instrument, book, and counterparty configured, so a trade has something to validate against (see Configuration).
• A market snapshot: a forward curve for the commodity you will trade, so the position can be valued.

If you are evaluating rather than deploying, these are pre-seeded in a demo environment, so you can book a trade in your first few minutes without configuring anything.

The fastest way to understand Gravitas is to book a trade and watch it flow. In Trade Capture, choose an instrument, enter quantity, price, delivery, and counterparty, and submit. Validation runs on entry, and the trade lands on the shared model, from where every downstream function sees it at once:

• It is immediately available to Valuation for mark-to-market.
• Risk picks it up in the live position for VaR and Greeks.
• Physical trades appear in Scheduling for nomination.
• On settlement, it flows to Settlements and the ledger.

The same booking is a single API call, and everything the UI did happens identically, because the UI runs on the same API. Authenticate, then POST the trade:

pythonfrom gravitas import Client

client = Client(client_id="svc-getting-started", client_secret=SECRET)

# 1. Book a trade. Validation, capture, and fan-out happen server-side.
trade = client.trades.book(
    book="GAS-EU", instrument="TTF-MONTH", buy_sell="BUY",
    quantity=50_000, price=32.15, delivery_period="2026-08",
    counterparty="ACME-ENERGY")
print(trade.trade_id, trade.status)          # TR-000184213 captured

# 2. Value it. Same governed position the UI shows.
val = client.valuations.get(trade.trade_id)
print(val.mtm_value, val.delta)              # marked against the live curve

# 3. See it in the live book-level position and risk.
pos = client.positions.get(book="GAS-EU")
print(pos.net_quantity, pos.var_95)          # your trade is already in here

Every module reads and writes the same governed model, so a trade captured once needs no re-keying downstream. This is what lets position, P&L, and risk reconcile with the front and back office instead of drifting across disconnected systems. The diagram below is the whole architecture in one picture: many functions, one model.

To go from zero to a booked, valued, risked trade:

1. Log in, or obtain a client credential for the API.
2. Confirm a commodity, instrument, book, and counterparty exist (or use the demo seed).
3. Book a trade in Trade Capture, or POST to /v1/trades.
4. Open Valuation to see it marked to market, or GET /v1/valuations/{tradeId}.
5. Open Risk to see it in the live position, or GET /v1/positions?book=....

From here, the Configuration, Administration, and Operations guides cover making the platform yours, running it, and keeping it healthy. For integration, see the API reference, and for the thinking behind the architecture, the cloud-native ETRM whitepaper.