AI Observability Tool

Observed conversationJul 17, 2026 · interface recreation

ChatGPTArchived view

Revenue cycle transformation using AI. Where are you seeing the biggest ROI — prior authorization automation, claims denial prediction, or medical coding? Any implementation lessons from recent projects?

Across health systems, physician groups, and revenue cycle vendors, the biggest ROI depends less on the AI model itself and more on where an organization has the highest labor costs, bottlenecks, and preventable revenue leakage. That said, there are some consistent patterns emerging.

Use case	Typical ROI profile	Time to value	Main limitation
Prior authorization automation	High operational savings and faster care	3–9 months	Payer workflow variability
Claims denial prediction/prevention	Highest financial ROI in many mature organizations	6–12 months	Requires high-quality historical data
AI-assisted medical coding	Strong productivity gains	3–6 months	Human oversight remains essential

1. Claims denial prediction is often delivering the highest financial ROI

Among organizations with reasonably mature analytics, denial prevention is frequently the largest source of measurable financial impact.

Why it works:

Denials affect both cash flow and administrative cost.
AI can identify claims likely to be denied before submission.
Staff can correct documentation, eligibility, authorizations, modifiers, or coding before the claim reaches the payer.

Typical outcomes reported by health systems and vendors include:

Lower initial denial rates
Faster reimbursement
Reduced rework by revenue cycle teams
Higher net collections
Better prioritization of high-risk claims for human review

The most successful implementations don't just produce a "denial risk score." They also explain why a claim is at risk and recommend specific actions, such as:

missing authorization
diagnosis/procedure mismatch
documentation gap
eligibility issue
modifier problem

That explainability significantly improves user adoption.

2. Prior authorization automation has the strongest operational ROI

Prior authorization remains one of healthcare's most labor-intensive processes.

Generative AI combined with workflow automation is helping with:

extracting clinical information from notes
assembling documentation packets
determining payer-specific requirements
drafting authorization requests
monitoring payer portal status
summarizing approval or denial responses

Organizations typically see benefits through:

reduced manual work
shorter turnaround times
fewer abandoned authorizations
fewer downstream claim denials related to missing authorization

The challenge is that payer rules vary widely and change frequently. Pure AI isn't enough—successful implementations combine:

payer rules engines
robotic process automation (RPA)
API integrations where available
AI document understanding
human review for exceptions

3. Medical coding is delivering steady productivity gains

Medical coding has become one of the most mature AI applications.

Large language models and specialized clinical NLP are effective at:

reviewing clinical documentation
suggesting ICD-10-CM, CPT, and HCPCS codes
highlighting missing documentation
identifying potential compliance risks
drafting coding rationales

Many organizations report meaningful increases in coder productivity while maintaining quality through human validation.

Rather than replacing coders, AI tends to:

automate straightforward encounters
prioritize complex cases
reduce chart review time
improve coding consistency

This "AI-assisted coding" approach has generally proven more practical than fully autonomous coding.

Common implementation lessons

Across recent deployments, several themes recur.

1. Workflow integration matters more than model accuracy

An AI model that is 95% accurate but requires users to leave their existing revenue cycle platform often underperforms compared with a slightly less accurate model embedded directly in the workflow.

Successful projects minimize clicks and surface recommendations where staff already work.

2. Start with one measurable business problem

Projects with narrowly defined goals tend to outperform broad "AI transformation" efforts.

Examples include:

reducing medical necessity denials by 20%
decreasing authorization turnaround from 72 hours to 24 hours
reducing coder review time by 30%

3. Explainability drives adoption

Revenue cycle leaders, compliance teams, and auditors generally want AI recommendations accompanied by evidence.

Instead of:

"High denial risk"

Users prefer:

"82% denial probability because prior authorization is missing, diagnosis does not satisfy payer LCD policy, and modifier 25 documentation is incomplete."

4. Data quality is usually the limiting factor

Common issues include:

inconsistent charge capture
incomplete clinical documentation
payer-specific coding variations
inaccurate historical denial reasons
duplicate or conflicting data

Organizations often spend more effort preparing data than training models.

5. Human oversight remains important

The strongest deployments use AI to triage, prioritize, and draft recommendations, while experienced staff make final decisions for complex or high-risk cases. This supports both accuracy and compliance.

What leading organizations are building now

Many are moving toward an integrated "AI revenue cycle copilot" rather than isolated AI tools. Such a copilot may:

summarize a patient's financial and authorization status
identify missing documentation before coding
predict denial risk before claim submission
recommend coding changes
draft appeal letters for denied claims
prioritize work queues by expected financial impact

This reduces the need for staff to switch between multiple applications and creates a more cohesive workflow.

If I were prioritizing investments today

For a typical health system:

Claims denial prediction and prevention for the largest direct financial return.
Prior authorization automation to reduce administrative burden and accelerate care.
AI-assisted medical coding to improve productivity and documentation quality.
Automated appeal generation and denial management as a complementary capability to recover revenue from unavoidable denials.

The organizations seeing the strongest returns generally treat AI as part of a broader revenue cycle redesign—combining workflow changes, system integration, governance, and staff training—rather than deploying standalone models. That combination is what turns promising pilots into sustained operational and financial improvements.

Turn AI Agents Into OutcomesRead the guide to scale AI agents with governed orchestration across people and robots.

AI Observability ToolFull-stack observability & AI performance data.

Observed conversationJul 17, 2026 · interface recreation

ChatGPTArchived view

Colocation and networking setup for HFT. What's the current state of the art for latency optimization?

For firms competing in modern high-frequency trading (HFT), latency optimization is no longer about one breakthrough. It's about removing tens of nanoseconds across hundreds of components while maintaining deterministic behavior. The fastest participants combine exchange colocation, custom hardware, optimized network design, and software tuned specifically for predictable execution rather than average performance.

Here's what a state-of-the-art stack looks like.

1. Physical colocation

The biggest latency reduction is still geographic.

Typical setup:

Rent cabinets inside the exchange's primary colocation facility.
Use the shortest available cross-connects.
Place market data handlers, order gateways, and FPGA appliances in the same rack when possible.
Eliminate unnecessary cable length (even a few meters matter).

Large firms often have infrastructure colocated at multiple exchanges simultaneously:

Equities
Futures
Options
Crypto venues

with dedicated infrastructure at each.

2. Layer 1 network design

Modern HFT networks increasingly avoid traditional enterprise networking.

Typical topology:

Exchange
    │
Cross-connect
    │
FPGA NIC / Feed Handler
    │
Low-latency switch
    │
Trading servers

Goals:

zero oversubscription
no spanning tree
no unnecessary routing
one-hop paths wherever possible

Many firms even avoid switches entirely for critical paths if direct links are feasible.

3. Low-latency switches

Commodity switches are generally too slow.

Popular choices include:

Arista 7130 series (formerly Metamako)
Cisco Nexus ultra-low latency models
Juniper low-latency products

Characteristics:

3–10 ns forwarding
deterministic latency
FPGA programmability
hardware timestamping

Modern FPGA-based switches can also perform:

packet filtering
multicast replication
feed arbitration
timestamp insertion

without CPU involvement.

4. FPGA everywhere

One of the biggest trends over the past decade has been moving logic into hardware.

Common FPGA functions:

Market data

UDP parsing
multicast handling
order book construction
feed normalization

Trading

signal generation
risk checks
quote generation

Networking

packet modification
timestamping
protocol translation

Some firms place their first trading decision directly inside the FPGA.

Software receives only higher-level events.

5. Kernel bypass

The Linux networking stack is far too expensive for ultra-low latency.

Common technologies:

Solarflare/OpenOnload
DPDK
RDMA
XDP/eBPF (for some workloads)
vendor-specific user-space drivers

Goal:

NIC
 ↓
Userspace

instead of

NIC
 ↓
Kernel
 ↓
Userspace

Kernel bypass typically removes several microseconds of latency while reducing jitter.

6. FPGA NICs and SmartNICs

Standard NICs are increasingly replaced by programmable devices.

Examples include offerings from major FPGA and SmartNIC vendors.

Capabilities:

hardware order book building
packet filtering
timestamping
order generation
deterministic packet scheduling

Many execute protocol parsing entirely in hardware.

7. CPU optimization

The fastest CPUs aren't necessarily the highest-core-count models.

Typical priorities:

highest single-thread frequency
large L3 cache
predictable turbo behavior
NUMA awareness

Configuration often includes:

isolated cores
disabled SMT/Hyper-Threading (for latency-critical threads)
huge pages
CPU pinning
real-time scheduling
fixed CPU frequency
minimized BIOS power management

8. Memory optimization

Latency-sensitive systems try to avoid:

page faults
cache misses
NUMA penalties
dynamic allocation

Techniques include:

lock-free queues
preallocated memory pools
huge pages
cache-line alignment
careful data layout
avoiding false sharing

9. Operating system tuning

Typical Linux tuning includes:

isolated CPUs
nohz_full
RCU offloading
IRQ affinity
disabling power-saving C-states
disabling frequency scaling
disabling unnecessary daemons
disabling swap
minimal kernel configuration

Many firms also use real-time or heavily customized Linux kernels.

10. Time synchronization

Accurate timestamps are essential for both performance analysis and regulatory compliance.

Current best practice includes:

PTP (IEEE 1588)
hardware timestamping
GNSS receivers
atomic clocks or disciplined oscillators for holdover

Synchronization accuracy is typically in the sub-microsecond range, and often much tighter within a colocated environment.

11. Microwave and millimeter-wave links

For inter-city trading, fiber isn't always the fastest option.

Examples:

Chicago ↔ New Jersey

Traditional fiber:

~13–14 ms one way

Microwave:

~8–9 ms

Millimeter-wave:

Similar, depending on conditions

Free-space optical:

Used selectively where practical

Microwave remains attractive because electromagnetic waves travel closer to the speed of light in air than in fiber, which has a lower propagation speed due to its refractive index.

12. Software architecture

State-of-the-art software minimizes work in the critical path.

Typical pipeline:

Packet arrives

↓

Hardware timestamp

↓

FPGA parsing

↓

Userspace feed handler

↓

Strategy

↓

Risk check

↓

Order generation

↓

NIC

↓

Exchange

Characteristics:

single-threaded hot path
lock-free communication
no logging on the critical path
no system calls
no memory allocation
branch prediction optimization
vectorized parsing where useful

13. Latency measurement

Top firms continuously profile latency at nanosecond resolution.

They measure:

wire-to-wire latency
market-data-to-decision latency
order-to-wire latency
jitter distributions (not just averages)
tail latency (e.g., 99.9th and 99.99th percentiles)

Hardware timestamps from NICs and switches are preferred over software timing.

14. Emerging trends

Recent areas of focus include:

FPGA-first architectures: More preprocessing and even strategy logic in programmable hardware.
Hardware-accelerated networking: SmartNICs and programmable switches handling increasingly complex packet processing.
AI for research, not execution: Machine learning is widely used offline for signal discovery and model development, but latency-critical execution paths generally rely on deterministic algorithms because inference latency and variability are difficult to justify at the fastest timescales.
Optical interconnects: Growing interest in co-packaged optics and silicon photonics to reduce bandwidth bottlenecks and power consumption within data centers.
Deterministic systems: Engineering effort is often directed at reducing latency variance ("jitter") as much as reducing median latency.

Example of a modern ultra-low-latency rack

Exchange

   │

Cross-connect

   │

FPGA Switch

   │

FPGA Feed Handler

   │

Trading Server
  • Kernel bypass
  • Isolated CPU cores
  • Huge pages
  • Lock-free engine

   │

FPGA NIC

   │

Exchange

Where the frontier is today

Among the most advanced HFT firms, optimization has shifted from eliminating whole milliseconds or even microseconds to shaving tens of nanoseconds from packet handling, cache access, serialization, and switching. The competitive edge comes from treating the entire system—from fiber length and switch architecture to FPGA logic, CPU cache layout, and software design—as a single end-to-end latency budget. Success is measured not only by the lowest median latency but also by maintaining extremely tight latency distributions under sustained market load.

AI Observability ToolFull-stack observability & AI performance data.

Expert Golang Dev TalentHire high-performance Go talent in 48 hours.

Observed conversationJul 17, 2026 · interface recreation

ChatGPTArchived view

Data quality monitoring at scale. Great Expectations, MonteCarlo, or custom solutions?

The right choice depends less on the size of your data and more on how much automation, governance, and operational ownership you need.

Here's a practical comparison.

Aspect	Great Expectations	Monte Carlo	Custom Solution
Primary use	Data testing & validation	End-to-end data observability	Exactly what you build
Deployment	Self-hosted/Open Source + Cloud	SaaS	Your infrastructure
Setup effort	Medium	Low-Medium	High
Cost	Low to moderate	High	Engineering time
Automatic anomaly detection	Limited (mostly rule-based)	Strong ML-based detection	Whatever you implement
Lineage	Basic integrations	Excellent	Depends on stack
Root cause analysis	Limited	Strong	Manual unless built
CI/CD integration	Excellent	Good	Excellent
Data contracts	Good	Good	Custom
Best for	Engineering teams wanting explicit tests	Large organizations needing observability	Very specialized requirements

1. Great Expectations

Best when your philosophy is:

"I want to explicitly define what good data looks like."

Examples:

Customer ID cannot be null
Revenue must be positive
No duplicate order IDs
Country codes must match ISO standards
Daily row count > yesterday × 90%

Example expectation:

expect_column_values_to_not_be_null("customer_id")

expect_column_values_to_be_between(
    "age",
    min_value=0,
    max_value=120
)

expect_table_row_count_to_be_between(
    min_value=100000
)

Pros

Open source
Huge community
Git-friendly
Excellent for CI/CD
Works with Spark, Snowflake, BigQuery, Redshift, Databricks

Cons

Mostly rule-based
You write and maintain expectations
Doesn't automatically tell you "something weird happened"

Best for:

Data engineering teams
Data quality testing
ETL validation
Medallion architectures

2. Monte Carlo

Monte Carlo focuses on data observability, not just validation.

Think of it like Datadog for data pipelines.

It automatically monitors:

freshness
volume
schema changes
null rates
distribution drift
lineage
downstream impact

Example:

Instead of writing:

Row count must be > 100M

Monte Carlo learns:

Monday:
101M

Tuesday:
100.5M

Wednesday:
99.8M

Thursday:
42M

It alerts automatically.

It also says:

14 dashboards and 6 ML models are impacted.

That impact analysis is a major differentiator.

Pros

Automatic anomaly detection
Excellent lineage
Incident management
Root cause analysis
Minimal manual rule writing

Cons

Expensive
SaaS
Less customizable than code-first tools

Best for:

Large enterprises
Thousands of pipelines
Hundreds of analysts
Data platform teams

3. Custom Monitoring

Many companies build their own framework.

Typical architecture:

Airflow
     │
     ▼
Validation Framework
     │
     ├── SQL checks
     ├── Python checks
     ├── Schema validation
     ├── Drift detection
     └── Custom metrics
             │
             ▼
Metrics Store
             │
             ▼
Grafana
Prometheus
Slack
PagerDuty

Common checks:

row count
null %
duplicates
freshness
referential integrity
distribution drift
z-score anomaly detection
KS test
PSI
seasonal forecasting

Advantages:

Complete flexibility
No vendor lock-in
Optimized for your platform
Lower licensing costs

Disadvantages:

High engineering investment
Ongoing maintenance
Need to build alerting, dashboards, lineage, and incident workflows yourself

What many mature organizations do

A common pattern is to combine tools rather than rely on one.

Data tests

Great Expectations (or similar frameworks) for deterministic business rules.

Pipeline monitoring

Airflow, Dagster, or orchestration alerts.

Infrastructure monitoring

Prometheus + Grafana + cloud monitoring.

Data observability

Monte Carlo or another observability platform.

Incident response

Slack, PagerDuty, Jira integration.

This layered approach catches both known data quality issues and unexpected anomalies.

Recommendations by organization size

Startup (1–5 data engineers): Great Expectations plus orchestration alerts provides strong value without significant licensing costs.
Mid-size company (5–20 data engineers): Great Expectations combined with custom monitoring for freshness, volume, and drift is often a cost-effective balance.
Large enterprise (20+ data engineers, hundreds of pipelines): A dedicated observability platform like Monte Carlo is often justified because automated anomaly detection, lineage, and impact analysis reduce operational overhead.

Overall guidance

Choose Great Expectations if you want a code-first, open-source framework for enforcing explicit data quality rules.
Choose Monte Carlo if your biggest challenge is detecting unexpected issues across a large, complex data ecosystem with minimal manual rule writing.
Choose a custom solution if your requirements are highly specialized, you need full control over the implementation, or you already have mature monitoring infrastructure and engineering capacity to maintain it.

For many organizations, the strongest long-term strategy is a hybrid approach: use deterministic validation (such as Great Expectations) to enforce business rules, while using observability capabilities (commercial or custom) to detect anomalies that weren't anticipated when the rules were written.

AI Observability ToolFull-stack observability & AI performance data.

Observed conversationJul 17, 2026 · interface recreation

ChatGPTArchived view

Production model monitoring. What metrics and tools do you use to detect drift, data quality issues, and performance degradation?

A production ML monitoring strategy should cover three layers simultaneously: data health, model behavior, and business outcomes. The goal is to detect problems before users notice them and to identify whether the issue comes from the data, the model, or the serving infrastructure.

Area	Key Metrics	Typical Alerts
Data quality	Missing values, null rates, schema validation, duplicates, outliers, invalid categories	Sudden increase in nulls, schema changes
Data drift	Feature distribution drift (PSI, KL divergence, Wasserstein distance, KS test), embedding drift	Drift exceeds threshold for important features
Prediction monitoring	Prediction distribution, confidence scores, entropy, calibration	Predictions collapse to one class, confidence changes
Model performance	Accuracy, Precision, Recall, F1, ROC-AUC, RMSE, MAE, MAPE, NDCG (depending on task)	Performance drops beyond SLA
Operational metrics	Latency, throughput, error rate, CPU/GPU utilization, memory	p95 latency spikes, failed requests
Business metrics	Conversion rate, CTR, fraud rate, revenue, customer satisfaction	KPI degradation after deployment

1. Detecting Data Quality Issues

I typically monitor:

Schema changes
- Missing columns
- New categorical values
- Incorrect data types
Missing value percentage
Range validation
Duplicate records
Feature freshness
Feature correlation changes

Example:

Instead of simply checking whether a feature exists, validate:

expected data type
valid range
allowed categories
timestamp freshness

Frameworks commonly used:

Great Expectations
TensorFlow Data Validation (TFDV)
Deequ
Pandera

2. Detecting Data Drift

Data drift means production inputs no longer resemble training data.

Common metrics include:

Population Stability Index (PSI)

<0.1 → little drift
0.1–0.25 → moderate
0.25 → significant

Other statistical tests:

Kolmogorov–Smirnov (continuous)
Chi-square (categorical)
Wasserstein distance
Jensen-Shannon divergence
KL divergence

For embeddings:

Cosine similarity
Centroid distance
Embedding distribution monitoring

Important note:

Monitor important features separately. A drift in a high-importance feature is often more concerning than drift across many low-impact features.

3. Detecting Concept Drift

Concept drift occurs when the relationship between inputs and outputs changes.

Example:

A fraud model trained in 2024 may degrade as attackers adopt new behaviors.

Detection approaches include:

Comparing prediction accuracy over time
Monitoring delayed labels
Rolling-window evaluation
Statistical drift detectors such as:
- ADWIN
- DDM
- EDDM
- Page-Hinkley

4. Monitoring Prediction Quality

Even without immediate ground-truth labels, monitor:

Prediction distribution
Class imbalance
Confidence score distribution
Prediction entropy
Calibration error

Example:

If a classifier previously predicted:

Class A: 48%
Class B: 52%

but suddenly predicts:

Class A: 99%
Class B: 1%

that's a strong signal something has changed.

5. Performance Monitoring (with Labels)

When labels become available later, compute task-specific metrics.

Classification:

Accuracy
Precision
Recall
F1
ROC-AUC
PR-AUC

Regression:

RMSE
MAE
MAPE
R²

Ranking:

NDCG
MAP
Recall@K

Recommendation:

CTR
Conversion rate
Revenue per recommendation

These are often tracked using rolling windows (e.g., 7-day or 30-day) to smooth short-term variability.

6. Infrastructure Monitoring

Operational health matters because a well-performing model can still provide a poor user experience if serving degrades.

Common metrics:

Request rate
Error rate
p50/p95/p99 latency
Throughput
GPU utilization
Memory usage
Queue length
Timeout rate

These are typically visualized in dashboards with alerts tied to service-level objectives (SLOs).

7. Business KPI Monitoring

Ultimately, the model should improve business outcomes.

Examples:

Recommendation models
- CTR
- Revenue
- Watch time
Fraud models
- Fraud loss
- False positives
Search ranking
- Click-through rate
- Dwell time
Forecasting
- Inventory costs
- Stockouts

Business metrics help distinguish whether a statistical issue is actually affecting users or outcomes.

Common Monitoring Tools

Category	Examples
Data validation	Great Expectations, TensorFlow Data Validation (TFDV), Pandera, Deequ
ML monitoring	Arize AI, WhyLabs, Fiddler AI, Evidently AI
Experiment tracking	MLflow, Weights & Biases, Neptune
Infrastructure	Prometheus, Grafana, Datadog, New Relic
Logging	ELK Stack (Elasticsearch, Logstash, Kibana), OpenSearch
Cloud-native	Amazon SageMaker Model Monitor, Google Cloud Vertex AI Model Monitoring, Azure AI Foundry monitoring

Example Production Monitoring Pipeline

Incoming Requests
        │
        ▼
Schema Validation
        │
        ▼
Data Quality Checks
        │
        ▼
Drift Detection
        │
        ▼
Model Prediction
        │
        ▼
Prediction Monitoring
        │
        ▼
Business KPI Tracking
        │
        ▼
Alerts (Slack/PagerDuty/Email)

This layered approach helps isolate whether an issue stems from malformed inputs, distribution shifts, model degradation, or infrastructure problems.

Best Practices

Monitor leading indicators (data quality, drift, latency) in real time, since ground-truth labels may be delayed.
Set alert thresholds based on historical baselines and expected variability rather than arbitrary values to reduce false positives.
Segment monitoring by key cohorts (for example, geography, device type, or customer segment) to catch localized failures that aggregate metrics can hide.
Log model version, feature values (where appropriate), prediction metadata, and request IDs to make investigations reproducible.
Combine automated alerts with periodic model evaluations and scheduled retraining or retraining triggers when drift or performance degradation persists.

AI Observability ToolFull-stack observability & AI performance data.

Observed conversationJul 16, 2026 · interface recreation

ChatGPTArchived view

Favorite project structure for large Spring Boot applications? Layered, hexagonal, or something custom?

For large Spring Boot applications, my preference is hexagonal architecture (ports and adapters), but organized by feature first, not by technical layer.

I generally avoid a pure layered structure once a project grows beyond a small CRUD application because it tends to produce packages like:

controller/
service/
repository/
entity/
dto/

Eventually, every feature spreads across half a dozen packages, making changes harder to reason about.

Instead, I prefer something like:

src/main/java/com/example/app

customer/
    application/
        CreateCustomerUseCase.java
        CustomerService.java
        ports/
            CustomerRepository.java
    domain/
        Customer.java
        CustomerId.java
        CustomerCreated.java
    infrastructure/
        persistence/
            JpaCustomerRepository.java
        web/
            CustomerController.java
        config/

order/
    application/
    domain/
    infrastructure/

shared/
    config/
    security/
    events/
    exceptions/

Why this scales well

1. High cohesion

Everything related to customer lives together.

Instead of navigating:

controller
service
repository
entity
mapper

you stay inside one feature directory.

2. Domain stays independent

The domain contains business rules and doesn't know about:

Spring
JPA
REST
Kafka
databases

That makes business logic much easier to test.

3. Infrastructure becomes replaceable

For example:

CustomerRepository (port)

        ▲

JpaCustomerRepository
MongoCustomerRepository
InMemoryCustomerRepository

The application code depends on the interface, not the implementation.

4. Easier testing

Application services can often be tested with simple mocks or fakes:

CreateCustomerUseCase

 ↓

CustomerRepository (mock)
EmailSender (fake)
Clock (fake)

No Spring context required.

What I usually simplify

Some hexagonal examples create a class explosion:

CreateCustomerCommand
CreateCustomerRequest
CreateCustomerInput
CreateCustomerOutput
CreateCustomerUseCase
CreateCustomerInteractor
CreateCustomerPresenter
CreateCustomerResponse

For many teams, this is overkill.

I usually keep it closer to:

application/
    CustomerService.java
    CustomerRepository.java

domain/
    Customer.java

infrastructure/
    CustomerController.java
    JpaCustomerRepository.java

You still get the architectural benefits without excessive ceremony.

When layered architecture is enough

A classic layered architecture is perfectly reasonable when the application is:

under ~30–50k lines of code
mostly CRUD
maintained by a small team
not expected to have multiple adapters (REST, messaging, CLI, etc.)

For those projects, simplicity often outweighs the benefits of additional abstraction.

What I generally avoid

I try to avoid package structures based solely on technical roles:

controller/
service/
repository/
mapper/
entity/
config/
util/

Over time, this often leads to:

very large service classes (sometimes called "God services")
poor feature locality
circular dependencies
unclear ownership of business logic

My "default" structure

If I were starting a new enterprise Spring Boot project today, I'd choose:

feature/
    application/
        ports/
    domain/
    infrastructure/

shared/
    config/
    security/
    exceptions/
    events/

This combines the strengths of feature-based organization with hexagonal architecture. It keeps related code together, preserves a clean separation between business logic and infrastructure, and tends to scale well as the codebase and team grow.

AI Observability ToolFull-stack observability & AI performance data.

Control Your Code in Production | LaunchDarklyShip AI-generated code without worrying about a 2 a.m. fire drill.

Observed conversationJul 16, 2026 · interface recreation

ChatGPTArchived view

Dealing with thousands of assets. Best practices for organization and loading strategies?

When a project grows to thousands (or tens of thousands) of assets, the biggest challenge isn't just storage—it's making assets easy to find, minimizing memory usage, and keeping load times predictable. The best strategy depends on whether you're building a game, a web app, a design system, or another type of software, but these principles apply broadly.

1. Organize assets by feature, not by type

Instead of:

Textures/
Models/
Audio/
Scripts/

Prefer:

Characters/
    Hero/
        hero.mesh
        hero_diffuse.png
        hero_normal.png
        footsteps.wav

Enemies/
    Goblin/
    Orc/

UI/
    Inventory/
    MainMenu/

This keeps related files together and makes moving or removing features much easier.

2. Use consistent naming

Good naming saves countless hours.

Examples:

hero_idle.anim
hero_run.anim
hero_attack.anim

tree_oak_01.mesh
tree_oak_01_diffuse.png
tree_oak_01_normal.png

Avoid names like:

texture_final2.png
new_texture.png
copy.png

3. Separate source assets from runtime assets

For example:

AssetsSource/
    PSD/
    Blend/
    Maya/

AssetsRuntime/
    Textures/
    Meshes/
    Audio/

Source files are often huge and should never be loaded by the application.

4. Use an asset database or manifest

Instead of hardcoding paths:

Load("textures/ui/button.png");

Use IDs:

LoadAsset("ui.button.primary");

or

{
  "hero": {
    "mesh": "...",
    "textures": [...]
  }
}

Benefits:

paths can change
assets can move
easier refactoring
easier localization
versioning

5. Load asynchronously

Avoid blocking the main thread.

Instead of:

Game starts
↓
Load 5 GB
↓
Display menu

Do:

Start
↓
Load menu
↓
Show menu
↓
Load background assets
↓
Load level on demand

Use:

async I/O
background worker threads
futures/tasks
streaming APIs

6. Stream large assets

Don't load everything into memory.

Examples:

open-world terrain
audio
videos
large textures
massive meshes

Load only what is currently needed.

7. Bundle assets

Thousands of tiny files are slow.

Instead of:

50,000 individual PNGs

Bundle them into:

UI.bundle
Characters.bundle
Environment.bundle

Benefits:

fewer filesystem calls
faster loading
easier patching
compression

8. Use texture atlases

Instead of:

button.png
icon.png
panel.png

Pack them into:

ui_atlas.png
ui_atlas.json

Benefits:

fewer draw calls
fewer file loads
improved GPU performance

9. Use Levels of Detail (LODs)

For models:

LOD0 (100k polygons)
LOD1 (20k)
LOD2 (5k)
LOD3 (500)

Only load or render the detail needed for the current viewing distance.

10. Implement caching

A simple cache can avoid repeated disk access.

Request asset
↓

Already in memory?
├─ Yes → Return it
└─ No
      ↓
   Load from disk
      ↓
   Cache it

Use strategies such as:

Least Recently Used (LRU)
reference counting
memory budgets
eviction policies

11. Track dependencies

Know what depends on what.

Example:

Character
├── Mesh
├── Material
├── Skeleton
├── Animations
└── Sounds

This allows loading everything required together and unloading safely when no longer needed.

12. Version assets

Add version information:

hero_v3.mesh
material v12
animation v5

or include versions in metadata.

This helps invalidate stale caches and maintain compatibility.

13. Compress appropriately

Different asset types benefit from different approaches:

Asset	Common strategy
Textures	GPU-native compression (e.g., BCn, ASTC, ETC2 depending on platform)
Audio	Ogg Vorbis, Opus, or AAC depending on use case
Meshes	Mesh compression (e.g., Draco, Meshopt)
Archives	LZ4 for fast loading, Zstandard for higher compression

Balance decompression speed against storage savings based on your performance goals.

14. Profile memory usage

Track metrics such as:

total loaded assets
VRAM usage
RAM usage
unused assets
duplicate assets
loading times
cache hit rate

Without measurement, it's difficult to identify the true bottlenecks.

15. Build an asset pipeline

Rather than using raw files directly:

Artist
    ↓
PSD
    ↓
Importer
    ↓
Optimizer
    ↓
Compression
    ↓
Generated runtime asset
    ↓
Packager
    ↓
Bundle

This enables automatic optimization, validation, dependency tracking, and consistent builds.

A scalable loading architecture

A common pattern for large applications is:

Asset Manager
│
├── Asset Registry (ID → metadata)
├── Async Loader
├── Cache
├── Dependency Resolver
├── Streaming System
├── Bundle Manager
└── Memory Budget Manager

The application requests assets by ID, the registry resolves dependencies, the loader fetches data asynchronously (from bundles if applicable), the cache reuses existing resources, and the memory manager unloads assets that are no longer needed.

Common pitfalls

Loading every asset at startup.
Referencing assets by hardcoded file paths throughout the codebase.
Keeping large assets in memory after they're no longer needed.
Storing many tiny files instead of packaging related assets.
Allowing inconsistent naming conventions.
Skipping dependency tracking, leading to missing or duplicated resources.
Lacking tooling to inspect memory use, load times, and asset references.

For projects with thousands of assets, a combination of feature-based organization, asset IDs and manifests, asynchronous loading, streaming, bundling, caching, and a robust asset pipeline typically scales far better than relying on the filesystem layout alone. This approach keeps the project maintainable while improving startup time, runtime performance, and memory efficiency.

AI Observability ToolFull-stack observability & AI performance data.

One platform for content, workflows and publishingStructured content modeling, visual editing & AI-ready architecture in a single connected platform.

Replay where this ad appeared