use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav);

}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav); self.gp_response.roll_forward(gp_nav, proxy, as_of) } pub fn private_credit_price( &self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of));

&self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav); self.gp_response.roll_forward(gp_nav, proxy, as_of) } pub fn private_credit_price( &self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of)); (clean, dirty) } pub fn roll_forward<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); }

proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs .iter() .filter(|mark| mark.received <= as_of) .max_by_key(|mark| mark.period_end) .unwrap_or(&holding.entry_nav); self.gp_response.roll_forward(gp_nav, proxy, as_of) } pub fn private_credit_price( &self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of)); (clean, dirty) } pub fn roll_forward<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); } if let HoldingKind::PrivateCredit(loan) = &holding.kind { let (clean, dirty) = self.private_credit_price(loan, as_of); value = value.with_credit_prices(clean, dirty); } value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund

&self, loan: &LoanPosition, as_of: NaiveDate, ) -> (CleanPrice, DirtyPrice) { let spread: CreditSpread = self .spreads .for_rating(loan.rating, as_of); let clean = loan.cash_flows.discount(spread, as_of); let dirty = clean.with_accrued_interest(loan.accrued(as_of)); (clean, dirty) } pub fn roll_forward<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); } if let HoldingKind::PrivateCredit(loan) = &holding.kind { let (clean, dirty) = self.private_credit_price(loan, as_of); value = value.with_credit_prices(clean, dirty); } value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund .holdings .iter() .map(|holding| self.roll_forward(holding, as_of)) .collect::<Vec<_>>(); DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;

&self, holding: &'h Holding, as_of: NaiveDate, ) -> Valuation<'h> { let proxy = self.peer_proxy(holding, as_of); let mut value = self.gp_response(holding, &proxy, as_of); for flow in self.cash_flows.for_holding(holding, as_of) { value = value.apply_cash_flow(flow); } if let HoldingKind::PrivateCredit(loan) = &holding.kind { let (clean, dirty) = self.private_credit_price(loan, as_of); value = value.with_credit_prices(clean, dirty); } value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund .holdings .iter() .map(|holding| self.roll_forward(holding, as_of)) .collect::<Vec<_>>(); DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self,

value } pub fn daily_nav( &self, fund: &Fund, as_of: NaiveDate, ) -> DailyNav { let valuations = fund .holdings .iter() .map(|holding| self.roll_forward(holding, as_of)) .collect::<Vec<_>>(); DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self

DailyNav::from_holdings(fund, valuations, as_of) }}use chrono::NaiveDate;use fev::market::{CleanPrice, CreditSpread, DirtyPrice};use fev::nav::{DailyNav, GpResponse, Valuation};use fev::pipeline::CleanStore;pub struct DailyNavEngine<'a> { sources: &'a SourceLake, cleaner: &'a Normalizer, peers: &'a PeerMatcher, spreads: &'a CreditSpreadCurve, gp_response: &'a GpResponseModel, cash_flows: &'a CashFlowLedger, store: &'a CleanStore,}impl<'a> DailyNavEngine<'a> { pub fn collect_sources( &self, as_of: NaiveDate, ) -> CleanStore { let raw = self.sources.collect(as_of); let cleaned = self.cleaner.normalize(raw); self.store.replace(cleaned) } pub fn peer_proxy<'h>( &self, holding: &'h Holding, as_of: NaiveDate, ) -> ProxyMove<'h> { let peers = self .peers .match_size_and_industry(holding, as_of); peers.weighted_move(holding.last_gp_period(), as_of) } pub fn gp_response<'h>( &self, holding: &'h Holding, proxy: &ProxyMove<'h>, as_of: NaiveDate, ) -> Valuation<'h> { let gp_nav = holding .gp_navs

Daily Private Market NAV at Scale

Made possible through our AI-Native Data Pipeline

Bias vs. GP Actuals: <1%
Per fund valuation time: .6s
Data points per fund: 2m

Model Status

FEV Data StoreOperationalQ1 26Q2 26Q3 26100% uptime

FEV PipelinesOperationalQ1 26Q2 26Q3 26100% uptime

Daily ValuationOperationalQ1 26Q2 26Q3 26100% uptime

From Custom Proxy to Validated Result in under a second

Each holding is valued against its own proxy, aggregated to fund and portfolio NAV, then checked by the validation engine.

Hyper-specific Company Level Proxy

Finally stop using imprecise broad indices. Our asset level proxies allow for smart benchmarking of private assets.

Built for every private asset class

: AI is changing what software businesses are worth, and public software stocks reprice with each development while GP marks arrive weeks to months after quarter end. We value each holding every day against public companies that map to its size and industry, so the fund's NAV reflects the change between reports.
: Sentiment toward private credit has turned quickly, with spreads widening most on loans to software borrowers. We calibrate each loan's discount rate at entry and move it with credit spreads every day, then report the loan at both a clean and a dirty price.
: Private funds are financing data centers, power generation and transmission to meet demand from AI and electrification, and they report on these assets quarterly. Our models value each asset every day in between, against the market signals that explain its economics.
: Listed real estate reprices every trading day while private appraisals adjust gradually, and the gap between public and private values has persisted since higher rates reset property prices. We roll each fund forward daily from its last reported NAV with market movement and cash flows, so market pricing reaches the fund between appraisals.

Every input is traceable. Every output is testable. Every valuation is auditable.

Hosted on AWS. AICPA SOC 1 and SOC 2 reports.

Breakthrough technology. Disruptive pricing.

The fastest way to judge a valuation method is to watch it run on a real portfolio.

We'll price one of yours.

Request a Demo