diff --git a/cmd/dashboard/main.go b/cmd/dashboard/main.go
index 25d6e59..3e26622 100644
--- a/cmd/dashboard/main.go
+++ b/cmd/dashboard/main.go
@@ -56,6 +56,9 @@ func main() {
 	// Initialize FinOps Engine
 	finopsEngine := finops.NewEngine(vmClient, st.PricingCatalog())
 
+	// Share Pricing Catalog with VM Client
+	vmClient.SetPricingCatalog(st.PricingCatalog())
+
 	auth.SetSecret(cfg.JWTSecret)
 
 	srv := &http.Server{
diff --git a/docs/TECHDEBT.md b/docs/TECHDEBT.md
index a2fbc10..3a80bf6 100644
--- a/docs/TECHDEBT.md
+++ b/docs/TECHDEBT.md
@@ -15,3 +15,7 @@
 ## Future Considerations
 - [ ] **Retention Policies**: Configure distinct retention periods for high-precision metrics (15s interval) vs. aggregated historical data.
 - [ ] **Refactor Store Locking**: Evaluate moving from heavy `RWMutex` usage in `store.go` to a more concurrent pattern if contention increases with 100+ agents.
+- [ ] **Dynamic Pricing & Savings Plans Support**:
+    - Problem: Agents no longer send costs; backend relies on static On-Demand rates.
+    - Solution: Implement a **Dynamic Pricing Engine** with DB overrides for Savings Plans, Reserved Instances, and Spot Pricing.
+    - Design: See `dynamic_pricing_design.md` artifact.
diff --git a/internal/api/handlers_health_test.go b/internal/api/handlers_health_test.go
index f5cf9b9..6dd6ba0 100644
--- a/internal/api/handlers_health_test.go
+++ b/internal/api/handlers_health_test.go
@@ -47,6 +47,12 @@ func (f *fakeMetricsProvider) ClusterMetadata(context.Context) (store.ClusterMet
 func (f *fakeMetricsProvider) NetworkTopology(context.Context, store.NetworkTopologyOptions) ([]store.NetworkEdge, error) {
 	return nil, vm.ErrNoData
 }
+func (f *fakeMetricsProvider) GetNodeStats(context.Context, string, string, time.Duration) (store.NodeStats, error) {
+	return store.NodeStats{}, vm.ErrNoData
+}
+func (f *fakeMetricsProvider) GetNodePods(context.Context, string, string, time.Duration) ([]store.PodMetrics, error) {
+	return nil, vm.ErrNoData
+}
 
 func newTestHandler(meta store.ClusterMetadata, status store.AgentStatusPayload) *Handler {
 	return &Handler{vm: &fakeMetricsProvider{meta: meta, status: status}}
diff --git a/internal/api/handlers_nodes.go b/internal/api/handlers_nodes.go
index fcb30ef..b6a3884 100644
--- a/internal/api/handlers_nodes.go
+++ b/internal/api/handlers_nodes.go
@@ -2,6 +2,7 @@ package api
 
 import (
 	"net/http"
+	"time"
 
 	"github.com/go-chi/chi/v5"
 
@@ -22,6 +23,7 @@ func (h *Handler) Nodes(w http.ResponseWriter, r *http.Request) {
 		Search: q.Get("search"),
 		Limit:  parseLimit(q.Get("limit"), defaultNodeLimit, maxNodeLimit),
 		Offset: parseOffset(q.Get("offset")),
+		Window: q.Get("window"), // "24h", "7d", "30d"
 	}
 
 	resp, err := h.vm.NodeList(ctx, filter)
@@ -58,3 +60,49 @@ func (h *Handler) NodeDetail(w http.ResponseWriter, r *http.Request) {
 
 	writeJSON(w, http.StatusOK, node)
 }
+
+// NodeStats returns historical usage and cost stats for a node.
+func (h *Handler) NodeStats(w http.ResponseWriter, r *http.Request) {
+	name := chi.URLParam(r, "name")
+	if name == "" {
+		writeError(w, http.StatusBadRequest, "node name is required")
+		return
+	}
+	windowStr := r.URL.Query().Get("window")
+	window, _ := time.ParseDuration(windowStr)
+	if window <= 0 {
+		window = 24 * time.Hour
+	}
+
+	ctx := vm.WithClusterID(r.Context(), clusterIDFromRequest(r))
+	stats, err := h.vm.GetNodeStats(ctx, "", name, window)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	writeJSON(w, http.StatusOK, stats)
+}
+
+// NodePods returns the list of pods for a node with P95 metrics (Pod Audit).
+func (h *Handler) NodePods(w http.ResponseWriter, r *http.Request) {
+	name := chi.URLParam(r, "name")
+	if name == "" {
+		writeError(w, http.StatusBadRequest, "node name is required")
+		return
+	}
+	windowStr := r.URL.Query().Get("window")
+	window, _ := time.ParseDuration(windowStr)
+	if window <= 0 {
+		window = 24 * time.Hour
+	}
+
+	ctx := vm.WithClusterID(r.Context(), clusterIDFromRequest(r))
+	pods, err := h.vm.GetNodePods(ctx, "", name, window)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	writeJSON(w, http.StatusOK, pods)
+}
diff --git a/internal/api/router.go b/internal/api/router.go
index 28d403a..778f45d 100644
--- a/internal/api/router.go
+++ b/internal/api/router.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"net/http"
+	"time"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
@@ -28,6 +29,8 @@ type MetricsProvider interface {
 	Agents(ctx context.Context) ([]store.AgentInfo, error)
 	ClusterMetadata(ctx context.Context) (store.ClusterMetadata, error)
 	NetworkTopology(ctx context.Context, opts store.NetworkTopologyOptions) ([]store.NetworkEdge, error)
+	GetNodeStats(ctx context.Context, clusterID, nodeName string, window time.Duration) (store.NodeStats, error)
+	GetNodePods(ctx context.Context, clusterID, nodeName string, window time.Duration) ([]store.PodMetrics, error)
 }
 
 // Handler wires HTTP requests to the VictoriaMetrics client.
@@ -73,6 +76,8 @@ func NewRouter(vmClient MetricsProvider, db *db.Store, st *store.Store, finopsEn
 				cost.Get("/namespaces/{name}", h.NamespaceDetail)
 				cost.Get("/nodes", h.Nodes)
 				cost.Get("/nodes/{name}", h.NodeDetail)
+				cost.Get("/nodes/{name}/stats", h.NodeStats)
+				cost.Get("/nodes/{name}/pods", h.NodePods)
 				cost.Get("/resources", h.Resources)
 			})
 			protected.Get("/agent", h.AgentStatus)
diff --git a/internal/store/pricing.go b/internal/store/pricing.go
index 3d4e060..6ddaaef 100644
--- a/internal/store/pricing.go
+++ b/internal/store/pricing.go
@@ -1,6 +1,11 @@
 package store
 
-import "context"
+import (
+	"context"
+	"fmt"
+
+	"github.com/clustercost/clustercost-dashboard/internal/pricing"
+)
 
 // Pricing constants
 const (
@@ -10,51 +15,33 @@ const (
 	CostEgressInternal = 0.00 // Free
 )
 
-// PricingProvider defines the interface for fetching node pricing.
-type PricingProvider interface {
-	GetNodePrice(ctx context.Context, region, instanceType string) (float64, error)
-}
-
 // PricingCatalog allows looking up node prices.
 type PricingCatalog struct {
-	// Map instance type to hourly price
-	InstancePrices map[string]float64
-	Provider       PricingProvider
+	// No provider needed, we use static data from internal/pricing
 }
 
-// NewPricingCatalog returns a catalog with some default mocked pricing.
-func NewPricingCatalog(provider PricingProvider) *PricingCatalog {
-	return &PricingCatalog{
-		InstancePrices: map[string]float64{
-			"t3.medium": 0.0416,
-			"t3.large":  0.0832,
-			"m5.large":  0.096,
-			"m5.xlarge": 0.192,
-			"c5.large":  0.085,
-			"r5.large":  0.126,
-			"default":   0.05, // Fallback
-		},
-		Provider: provider,
-	}
+// NewPricingCatalog returns a catalog.
+func NewPricingCatalog() *PricingCatalog {
+	return &PricingCatalog{}
 }
 
 // GetTotalNodePrice returns the total hourly cost of a node.
 func (pc *PricingCatalog) GetTotalNodePrice(ctx context.Context, region, instanceType string) float64 {
-	// Try Provider first
-	if pc.Provider != nil && instanceType != "" && region != "" {
-		price, err := pc.Provider.GetNodePrice(ctx, region, instanceType)
-		if err == nil && price > 0 {
-			pc.InstancePrices[instanceType] = price // Update cache
-			return price
-		}
+	// 1. Try Shared Static Data
+	key := fmt.Sprintf("%s|%s", region, instanceType)
+	if price, ok := pricing.InstancePrices[key]; ok {
+		return price
 	}
 
-	// Fallback to local cache
-	price, ok := pc.InstancePrices[instanceType]
-	if !ok {
-		price = pc.InstancePrices["default"]
+	// 2. Fallback to generic defaults if completely unknown
+	// check if we have a default for the instance type regardless of region (common for US-East-1 based defaults)
+	// (Optional optimization: try "us-east-1|instanceType" as fallback?)
+	fallbackKey := fmt.Sprintf("us-east-1|%s", instanceType)
+	if price, ok := pricing.InstancePrices[fallbackKey]; ok {
+		return price
 	}
-	return price
+
+	return 0.05 // Ultimate fallback
 }
 
 // GetNodeResourcePrices calculates the cost per vCPU and per GB of RAM based on the instance type.
diff --git a/internal/store/pricing_test.go b/internal/store/pricing_test.go
index 7ab6916..630cdd7 100644
--- a/internal/store/pricing_test.go
+++ b/internal/store/pricing_test.go
@@ -6,7 +6,7 @@ import (
 )
 
 func TestPricingCatalog_GetNodeResourcePrices(t *testing.T) {
-	pc := NewPricingCatalog(nil)
+	pc := NewPricingCatalog()
 
 	// Test case 1: m5.large (2 vCPU, 8GB RAM)
 	// Price: $0.096/hr
diff --git a/internal/store/store.go b/internal/store/store.go
index 9df7b58..cda9041 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -11,7 +11,6 @@ import (
 	"math"
 
 	"github.com/clustercost/clustercost-dashboard/internal/config"
-	"github.com/clustercost/clustercost-dashboard/internal/pricing"
 	agentv1 "github.com/clustercost/clustercost-dashboard/internal/proto/agent/v1"
 )
 
@@ -122,12 +121,21 @@ type NodeSummary struct {
 	InstanceType           string            `json:"instanceType,omitempty"`
 	Labels                 map[string]string `json:"labels"`
 	Taints                 []string          `json:"taints"`
+	// Resource Requests (Allocated)
+	CPURequestedMilli    int64 `json:"cpuRequestedMilli"`
+	CPULimitMilli        int64 `json:"cpuLimitMilli"`
+	MemoryRequestedBytes int64 `json:"memoryRequestedBytes"`
+	MemoryLimitBytes     int64 `json:"memoryLimitBytes"`
 	// Network (Host Level)
 	NetTxBytes          int64 `json:"netTxBytes"`
 	NetRxBytes          int64 `json:"netRxBytes"`
 	EgressPublicBytes   int64 `json:"egressPublicBytes"`
 	EgressCrossAZBytes  int64 `json:"egressCrossAZBytes"`
 	EgressInternalBytes int64 `json:"egressInternalBytes"`
+	// Historical / Window Data
+	ActiveHours float64 `json:"activeHours"` // Hours active in the selected window
+	ActiveRatio float64 `json:"activeRatio"` // 0.0 - 1.0
+	WindowCost  float64 `json:"windowCost"`  // Actual cost incurred in the window
 }
 
 // NodeListResponse wraps paginated node results.
@@ -271,6 +279,7 @@ type NodeFilter struct {
 	Search string
 	Limit  int
 	Offset int
+	Window string // "24h", "7d", "30d"
 }
 
 // PodContext wraps a PodMetric with its location metadata.
@@ -282,6 +291,27 @@ type PodContext struct {
 	InstanceType string
 }
 
+// NodeStats contains historical usage and cost analysis for a node.
+type NodeStats struct {
+	NodeName              string  `json:"nodeName"`
+	P95CPUUsagePercent    float64 `json:"p95CpuUsagePercent"`
+	P95MemoryUsagePercent float64 `json:"p95MemoryUsagePercent"`
+	TotalMonthlyCost      float64 `json:"totalMonthlyCost"`
+	RealUsageMonthlyCost  float64 `json:"realUsageMonthlyCost"`
+	Window                string  `json:"window"`
+}
+
+// PodMetrics contains resource usage analysis for a single pod.
+type PodMetrics struct {
+	PodName            string  `json:"podName"`
+	Namespace          string  `json:"namespace"`
+	QoSClass           string  `json:"qosClass"`
+	CPURequestMilli    int64   `json:"cpuRequestMilli"`
+	CPUP95Milli        float64 `json:"cpuP95Milli"`
+	MemoryRequestBytes int64   `json:"memoryRequestBytes"`
+	MemoryP95Bytes     float64 `json:"memoryP95Bytes"`
+}
+
 // New creates a store seeded with agent configurations.
 func New(cfgs []config.AgentConfig, recommendedAgentVersion string) *Store {
 	agentConfigs := make(map[string]config.AgentConfig, len(cfgs))
@@ -290,14 +320,13 @@ func New(cfgs []config.AgentConfig, recommendedAgentVersion string) *Store {
 	}
 
 	// Initialize Static Pricing Provider
-	// Context is just placeholder for interface, static client doesn't need it
-	pricingClient, _ := pricing.NewAWSClient(context.Background())
+	// We use the static map from internal/pricing/data.go, so no dynamic client needed.
 
 	return &Store{
 		agentConfigs:            agentConfigs,
 		snapshots:               make(map[string]*AgentSnapshot, len(cfgs)),
 		recommendedAgentVersion: recommendedAgentVersion,
-		pricing:                 NewPricingCatalog(pricingClient),
+		pricing:                 NewPricingCatalog(),
 	}
 }
 
@@ -972,6 +1001,28 @@ func (s *Store) aggregateNodesLocked() (map[string]*NodeSummary, error) {
 		}
 		haveData = true
 
+		// Pre-calculate Pod Limits/Requests per Node
+		nodeLimits := make(map[string]struct {
+			cpuReq, cpuLim, memReq, memLim int64
+		})
+
+		for _, p := range snap.Report.Pods {
+			nodeName := snap.Report.NodeName
+			if nodeName == "" {
+				continue
+			}
+			stats := nodeLimits[nodeName]
+			if p.Cpu != nil {
+				stats.cpuReq += safeInt64(p.Cpu.RequestMillicores)
+				stats.cpuLim += safeInt64(p.Cpu.LimitMillicores)
+			}
+			if p.Memory != nil {
+				stats.memReq += safeInt64(p.Memory.RequestBytes)
+				stats.memLim += safeInt64(p.Memory.LimitBytes)
+			}
+			nodeLimits[nodeName] = stats
+		}
+
 		// Iterate over all nodes reported by this agent
 		for _, n := range snap.Report.Nodes {
 			if n == nil || n.NodeName == "" {
@@ -979,6 +1030,11 @@ func (s *Store) aggregateNodesLocked() (map[string]*NodeSummary, error) {
 			}
 			name := n.NodeName
 
+			// Use aggregated values from pods if available, fallback to node metric if generic
+			// The Agent V2 NodeMetric.Requested... is arguably the same, but doesn't have Limits.
+			// We prioritize our calculated limits.
+			podStats := nodeLimits[name]
+
 			entry, ok := nodes[name]
 			if !ok {
 				entry = &NodeSummary{
@@ -988,7 +1044,20 @@ func (s *Store) aggregateNodesLocked() (map[string]*NodeSummary, error) {
 					InstanceType:           "default", // placeholder
 					CPUAllocatableMilli:    safeInt64(n.AllocatableCpuMillicores),
 					MemoryAllocatableBytes: safeInt64(n.AllocatableMemoryBytes),
+					CPURequestedMilli:      safeInt64(n.RequestedCpuMillicores), // Fallback to agent metric
+					CPULimitMilli:          podStats.cpuLim,
+					MemoryRequestedBytes:   safeInt64(n.RequestedMemoryBytes), // Fallback to agent metric
+					MemoryLimitBytes:       podStats.memLim,
+					IsUnderPressure:        n.ThrottlingNs > 1_000_000,
+				}
+				// If agent metric is 0 (older agent?) use our aggregation for Requests too
+				if entry.CPURequestedMilli == 0 {
+					entry.CPURequestedMilli = podStats.cpuReq
 				}
+				if entry.MemoryRequestedBytes == 0 {
+					entry.MemoryRequestedBytes = podStats.memReq
+				}
+
 				nodes[name] = entry
 			}
 
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index 7702b7e..7911687 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -13,7 +13,7 @@ func newTestStore() *Store {
 	}
 	s := New(cfgs, "v1.0.0")
 	// Inject Mock Pricing
-	s.pricing = NewPricingCatalog(&MockPricing{})
+	s.pricing = NewPricingCatalog()
 	return s
 }
 
diff --git a/internal/vm/client.go b/internal/vm/client.go
index 91a7b8a..ecd5b7e 100644
--- a/internal/vm/client.go
+++ b/internal/vm/client.go
@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/clustercost/clustercost-dashboard/internal/config"
+	"github.com/clustercost/clustercost-dashboard/internal/store"
 )
 
 // ErrNoData indicates that VictoriaMetrics returned no usable data.
@@ -42,6 +43,12 @@ type Client struct {
 	cacheTTL                time.Duration
 	cacheMu                 sync.Mutex
 	cache                   map[string]cachedQuery
+	pricing                 *store.PricingCatalog
+}
+
+// SetPricingCatalog allows injecting the pricing catalog.
+func (c *Client) SetPricingCatalog(p *store.PricingCatalog) {
+	c.pricing = p
 }
 
 type cachedQuery struct {
@@ -376,6 +383,77 @@ func (c *Client) GetPodP95Usage(ctx context.Context, clusterID, namespace, podNa
 	return cpuCores, memoryBytes, nil
 }
 
+// GetNodeStats calculates the average usage and real cost of a node over a time window.
+func (c *Client) GetNodeStats(ctx context.Context, clusterID, nodeName string, window time.Duration) (store.NodeStats, error) {
+	if nodeName == "" {
+		return store.NodeStats{}, fmt.Errorf("node name is required")
+	}
+	if window <= 0 {
+		window = 24 * time.Hour
+	}
+	windowStr := formatDuration(window)
+
+	labels := map[string]string{
+		"node": nodeName,
+	}
+	if clusterID != "" {
+		labels["cluster_id"] = clusterID
+	}
+
+	// 1. Get P95 Usage %
+	// quantile_over_time(0.95, clustercost_node_cpu_usage_percent{node="name"}[window])
+	cpuQuery := fmt.Sprintf("quantile_over_time(0.95, clustercost_node_cpu_usage_percent%s[%s])",
+		formatLabels(labels), windowStr)
+	memQuery := fmt.Sprintf("quantile_over_time(0.95, clustercost_node_memory_usage_percent%s[%s])",
+		formatLabels(labels), windowStr)
+
+	// 2. Get Average Hourly Cost (to account for potential spot price fluctuations or just stability)
+	costQuery := fmt.Sprintf("avg_over_time(clustercost_node_hourly_cost%s[%s])",
+		formatLabels(labels), windowStr)
+
+	cpuSamples, err := c.query(ctx, cpuQuery)
+	if err != nil {
+		return store.NodeStats{}, fmt.Errorf("query cpu stats: %w", err)
+	}
+	memSamples, err := c.query(ctx, memQuery)
+	if err != nil {
+		return store.NodeStats{}, fmt.Errorf("query mem stats: %w", err)
+	}
+	costSamples, err := c.query(ctx, costQuery)
+	if err != nil {
+		return store.NodeStats{}, fmt.Errorf("query cost stats: %w", err)
+	}
+
+	p95Cpu := 0.0
+	if len(cpuSamples) > 0 {
+		p95Cpu = cpuSamples[0].value
+	}
+	p95Mem := 0.0
+	if len(memSamples) > 0 {
+		p95Mem = memSamples[0].value
+	}
+	avgHourlyCost := 0.0
+	if len(costSamples) > 0 {
+		avgHourlyCost = costSamples[0].value
+	}
+
+	// Calculate Costs
+	totalMonthly := avgHourlyCost * hoursPerMonth // 720 hours
+	// "Real Usage" = (Total * 0.5 * Cpu%) + (Total * 0.5 * Mem%)
+	// Percentages are 0-100 in VM usually (based on ingestion code: `writeFloatSample(..., cpuPct, ...)` where `cpuPct` was * 100)
+
+	realUsageMonthly := (totalMonthly * 0.5 * (p95Cpu / 100.0)) + (totalMonthly * 0.5 * (p95Mem / 100.0))
+
+	return store.NodeStats{
+		NodeName:              nodeName,
+		P95CPUUsagePercent:    p95Cpu,
+		P95MemoryUsagePercent: p95Mem,
+		TotalMonthlyCost:      totalMonthly,
+		RealUsageMonthlyCost:  realUsageMonthly,
+		Window:                windowStr,
+	}, nil
+}
+
 func formatLabels(labels map[string]string) string {
 	if len(labels) == 0 {
 		return ""
@@ -400,3 +478,133 @@ func formatLabels(labels map[string]string) string {
 	b.WriteByte('}')
 	return b.String()
 }
+
+// GetNodePods returns 24h P95 and Request metrics for all pods on a specific node.
+func (c *Client) GetNodePods(ctx context.Context, clusterID, nodeName string, window time.Duration) ([]store.PodMetrics, error) {
+	if nodeName == "" {
+		return nil, fmt.Errorf("node name is required")
+	}
+	if window <= 0 {
+		window = 24 * time.Hour
+	}
+	windowStr := formatDuration(window)
+
+	labels := map[string]string{
+		"node": nodeName,
+	}
+	if clusterID != "" {
+		labels["cluster_id"] = clusterID
+	}
+	labelStr := formatLabels(labels)
+
+	// We need 5 metrics per pod:
+	// 1. CPU Request (Max)
+	// 2. CPU Limit (Max) - to determine QoS
+	// 3. Mem Request (Max)
+	// 4. CPU Usage (P95)
+	// 5. Mem Usage (P95)
+
+	queries := map[string]string{
+		"cpu_req_max": fmt.Sprintf("max_over_time(clustercost_pod_cpu_request_millicores%s[%s])", labelStr, windowStr),
+		"cpu_lim_max": fmt.Sprintf("max_over_time(clustercost_pod_cpu_limit_millicores%s[%s])", labelStr, windowStr),
+		"mem_req_max": fmt.Sprintf("max_over_time(clustercost_pod_memory_request_bytes%s[%s])", labelStr, windowStr),
+		"cpu_add_p95": fmt.Sprintf("quantile_over_time(0.95, clustercost_pod_cpu_usage_milli%s[%s])", labelStr, windowStr),
+		"mem_add_p95": fmt.Sprintf("quantile_over_time(0.95, clustercost_pod_memory_rss_bytes%s[%s])", labelStr, windowStr),
+	}
+
+	// Helper struct to aggregate data
+	type podData struct {
+		Namespace string
+		PodName   string
+		CPUReq    float64
+		CPULim    float64
+		MemReq    float64
+		CPUP95    float64
+		MemP95    float64
+	}
+	podMap := make(map[string]*podData)
+
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var firstErr error
+
+	for key, query := range queries {
+		wg.Add(1)
+		go func(k, q string) {
+			defer wg.Done()
+			samples, err := c.query(ctx, q)
+			if err != nil {
+				mu.Lock()
+				if firstErr == nil {
+					firstErr = err
+				}
+				mu.Unlock()
+				return
+			}
+			mu.Lock()
+			for _, s := range samples {
+				ns := s.labels["namespace"]
+				pod := s.labels["pod"]
+				if ns == "" || pod == "" {
+					continue
+				}
+				id := ns + "|" + pod
+				if _, exists := podMap[id]; !exists {
+					podMap[id] = &podData{Namespace: ns, PodName: pod}
+				}
+				p := podMap[id]
+
+				switch k {
+				case "cpu_req_max":
+					p.CPUReq = s.value
+				case "cpu_lim_max":
+					p.CPULim = s.value
+				case "mem_req_max":
+					p.MemReq = s.value
+				case "cpu_add_p95":
+					p.CPUP95 = s.value
+				case "mem_add_p95":
+					p.MemP95 = s.value
+				}
+			}
+			mu.Unlock()
+		}(key, query)
+	}
+	wg.Wait()
+
+	if firstErr != nil {
+		return nil, fmt.Errorf("failed to query pod metrics: %w", firstErr)
+	}
+
+	results := make([]store.PodMetrics, 0, len(podMap))
+	for _, p := range podMap {
+		// QoS Logic
+		qos := "Burstable"
+		if p.CPUReq == 0 && p.MemReq == 0 {
+			qos = "BestEffort"
+		} else if p.CPUReq == p.CPULim && p.CPULim > 0 {
+			qos = "Guaranteed" // Simplified, strictly checking CPU for now
+		}
+
+		results = append(results, store.PodMetrics{
+			PodName:            p.PodName,
+			Namespace:          p.Namespace,
+			QoSClass:           qos,
+			CPURequestMilli:    int64(p.CPUReq),
+			CPUP95Milli:        p.CPUP95,
+			MemoryRequestBytes: int64(p.MemReq),
+			MemoryP95Bytes:     p.MemP95,
+		})
+	}
+
+	// Sort by Waste Amount (heuristic: max diff)
+	sort.Slice(results, func(i, j int) bool {
+		// Just sorting by name for stability for now, frontend handles logic sort
+		if results[i].Namespace != results[j].Namespace {
+			return results[i].Namespace < results[j].Namespace
+		}
+		return results[i].PodName < results[j].PodName
+	})
+
+	return results, nil
+}
diff --git a/internal/vm/dashboard.go b/internal/vm/dashboard.go
index 34cc685..31996e0 100644
--- a/internal/vm/dashboard.go
+++ b/internal/vm/dashboard.go
@@ -131,7 +131,7 @@ func (c *Client) NamespaceDetail(ctx context.Context, name string) (store.Namesp
 }
 
 func (c *Client) NodeList(ctx context.Context, filter store.NodeFilter) (store.NodeListResponse, error) {
-	nodes, ts, err := c.nodeMetrics(ctx, "")
+	nodes, ts, err := c.nodeMetrics(ctx, "", filter.Window)
 	if err != nil {
 		return store.NodeListResponse{}, err
 	}
@@ -169,7 +169,7 @@ func (c *Client) NodeList(ctx context.Context, filter store.NodeFilter) (store.N
 }
 
 func (c *Client) NodeDetail(ctx context.Context, name string) (store.NodeSummary, error) {
-	nodes, _, err := c.nodeMetrics(ctx, name)
+	nodes, _, err := c.nodeMetrics(ctx, name, "")
 	if err != nil {
 		return store.NodeSummary{}, err
 	}
@@ -198,10 +198,8 @@ func (c *Client) Resources(ctx context.Context) (store.ResourcesPayload, error)
 	if err != nil && err != ErrNoData {
 		return store.ResourcesPayload{}, err
 	}
-	nodeHourlyCost, _, err := c.scalarMetric(ctx, "clustercost_cluster_total_node_hourly_cost")
-	if err != nil && err != ErrNoData {
-		return store.ResourcesPayload{}, err
-	}
+	// Node Hourly Cost is now fully calculated, no stored metric
+	nodeHourlyCost := 0.0
 
 	// Fetch Network Metrics
 	netTx, _, _ := c.scalarMetric(ctx, "clustercost_cluster_network_tx_bytes_total")
@@ -432,7 +430,7 @@ func (c *Client) AgentStatus(ctx context.Context) (store.AgentStatusPayload, err
 	}
 
 	nsTS := c.seriesTimestampSafe(ctx, "clustercost_namespace_hourly_cost")
-	nodeTS := c.seriesTimestampSafe(ctx, "clustercost_node_hourly_cost")
+	nodeTS := c.seriesTimestampSafe(ctx, "clustercost_node_cpu_allocatable_milli")
 	resTS := c.seriesTimestampSafe(ctx, "clustercost_cluster_cpu_usage_milli_total")
 
 	datasets := store.AgentDatasetHealth{
@@ -678,36 +676,6 @@ func (c *Client) namespaceMetrics(ctx context.Context, environment, namespace st
 		}
 	}
 
-	queryScalar := func(expr string) (float64, error) {
-		samples, err := c.query(ctx, expr)
-		if err != nil {
-			return 0, err
-		}
-		if len(samples) == 0 {
-			return 0, ErrNoData
-		}
-		return samples[0].value, nil
-	}
-
-	nodeCostExpr := fmt.Sprintf("sum(max by (node) (%s))", c.lookbackExpr("clustercost_node_hourly_cost", nil, clusterID))
-	cpuAllocExpr := fmt.Sprintf("sum(max by (node) (%s))", c.lookbackExpr("clustercost_node_cpu_allocatable_milli", nil, clusterID))
-	memAllocExpr := fmt.Sprintf("sum(max by (node) (%s))", c.lookbackExpr("clustercost_node_memory_allocatable_bytes", nil, clusterID))
-
-	nodeCost, err := queryScalar(nodeCostExpr)
-	if err == nil && nodeCost > 0 {
-		cpuAllocMilli, errCPU := queryScalar(cpuAllocExpr)
-		memAllocBytes, errMem := queryScalar(memAllocExpr)
-		if errCPU == nil && errMem == nil && cpuAllocMilli > 0 && memAllocBytes > 0 {
-			cpuPrice := (nodeCost * 0.5) / (cpuAllocMilli / 1000.0)
-			memPrice := (nodeCost * 0.5) / (memAllocBytes / (1024.0 * 1024.0 * 1024.0))
-			for _, entry := range out {
-				cpuUsageCores := float64(entry.CPUUsageMilli) / 1000.0
-				memUsageGB := float64(entry.MemoryUsageBytes) / (1024.0 * 1024.0 * 1024.0)
-				entry.HourlyCost = (cpuUsageCores * cpuPrice) + (memUsageGB * memPrice)
-			}
-		}
-	}
-
 	latest = c.seriesTimestampSafe(ctx, "clustercost_namespace_memory_rss_bytes_total")
 
 	type nodeAlloc struct {
@@ -755,7 +723,12 @@ func (c *Client) namespaceMetrics(ctx context.Context, environment, namespace st
 		})
 	}
 
-	pricing := store.NewPricingCatalog(nil)
+	var pricing *store.PricingCatalog
+	if c.pricing != nil {
+		pricing = c.pricing
+	} else {
+		pricing = store.NewPricingCatalog()
+	}
 	totalNodeCost := 0.0
 	totalCpuCores := 0.0
 	totalMemGB := 0.0
@@ -785,7 +758,27 @@ func (c *Client) namespaceMetrics(ctx context.Context, environment, namespace st
 	return out, latest, nil
 }
 
-func (c *Client) nodeMetrics(ctx context.Context, nodeName string) (map[string]*store.NodeSummary, time.Time, error) {
+func (c *Client) Nodes(ctx context.Context, window string) ([]store.NodeSummary, error) {
+	nodeMetrics, _, err := c.nodeMetrics(ctx, "", window)
+	if err != nil {
+		return nil, err
+	}
+
+	out := make([]store.NodeSummary, 0, len(nodeMetrics))
+	for _, n := range nodeMetrics {
+		n.Labels = nil // Optimization: potentially clear heavy labels if not needed
+		out = append(out, *n)
+	}
+
+	// Sort by Cost desc
+	sort.Slice(out, func(i, j int) bool {
+		return out[i].WindowCost > out[j].WindowCost
+	})
+
+	return out, nil
+}
+
+func (c *Client) nodeMetrics(ctx context.Context, nodeName, window string) (map[string]*store.NodeSummary, time.Time, error) {
 	clusterID := c.resolveClusterID(ctx)
 	ctx = WithClusterID(ctx, clusterID)
 	labels := map[string]string{}
@@ -793,53 +786,169 @@ func (c *Client) nodeMetrics(ctx context.Context, nodeName string) (map[string]*
 		labels["node"] = nodeName
 	}
 
+	// Parse Window
+	var windowDur time.Duration
+	var lookbackFunc string = "max_over_time"  // Default for "current" view (snapshot-ish)
+	var windowStr string = c.lookback.String() // Default internal lookback
+
+	if window != "" {
+		d, err := time.ParseDuration(window)
+		if err == nil {
+			windowDur = d
+			windowStr = window
+			lookbackFunc = "avg_over_time"
+		}
+	} else {
+		// Assuming standard "current" view implies "1h" or just last scrape?
+		// For consistency with existing logic, we keep standard lookback but use max/last.
+	}
+
+	// If Windowed View: Primary source is agent_up to find ALL nodes active in window
+	// If Snapshot View: Primary source is usually node_info or just scraping metrics.
+	// We'll use the same multi-metric approach but adjust the aggregation.
+
+	out := make(map[string]*store.NodeSummary)
+
+	// Helper to safely assign to out map
+	getOrCreate := func(node string) *store.NodeSummary {
+		if node == "" {
+			return nil
+		}
+		if _, ok := out[node]; !ok {
+			out[node] = &store.NodeSummary{
+				NodeName: node,
+				Labels:   map[string]string{},
+				Taints:   []string{},
+			}
+		}
+		return out[node]
+	}
+
+	// 1. Availability / Active Time
+	// Query: avg_over_time(clustercost_agent_up[window])
+	// Value: 0.0 - 1.0 (fraction of time active)
+	availExpr := fmt.Sprintf("avg_over_time(clustercost_agent_up%s[%s])", formatLabels(c.scopedLabels(labels, clusterID)), windowStr)
+	availSamples, err := c.query(ctx, availExpr)
+	if err == nil {
+		for _, s := range availSamples {
+			node := s.labels["node"]
+			entry := getOrCreate(node)
+			if entry != nil {
+				entry.ActiveRatio = s.value
+				if windowDur > 0 {
+					entry.ActiveHours = s.value * windowDur.Hours()
+				} else {
+					// Default assumption if no window: 100% active (snapshot)
+					entry.ActiveRatio = 1.0
+					entry.ActiveHours = 24 * 30 // Monthly projection basis
+				}
+
+				// Extract Metadata from Agent Up
+				if entry.InstanceType == "" {
+					entry.InstanceType = valueOrDefault(s.labels["instance_type"],
+						valueOrDefault(s.labels["node_label_node_kubernetes_io_instance_type"],
+							s.labels["node_label_beta_kubernetes_io_instance_type"]))
+				}
+				if entry.Labels["topology_kubernetes_io_region"] == "" {
+					entry.Labels["topology_kubernetes_io_region"] = s.labels["cluster_region"]
+				}
+			}
+		}
+	}
+
+	// Helper to extract metadata from labels
+	updateMeta := func(entry *store.NodeSummary, labels map[string]string) {
+		if entry.InstanceType == "" {
+			entry.InstanceType = valueOrDefault(labels["instance_type"],
+				valueOrDefault(labels["node_label_node_kubernetes_io_instance_type"],
+					labels["node_label_beta_kubernetes_io_instance_type"]))
+		}
+		if entry.Labels["topology_kubernetes_io_region"] == "" {
+			entry.Labels["topology_kubernetes_io_region"] = labels["cluster_region"]
+		}
+	}
+
+	// 2. Metrics List
 	metrics := []struct {
-		name   string
-		assign func(entry *store.NodeSummary, value float64, labels map[string]string)
+		name          string
+		validLookback bool // if false, use standard lookback (e.g. for info that doesn't vary)
+		assign        func(entry *store.NodeSummary, value float64, labels map[string]string)
 	}{
-		{"clustercost_node_hourly_cost", func(e *store.NodeSummary, v float64, l map[string]string) {
-			e.HourlyCost = v
-			if e.InstanceType == "" {
-				e.InstanceType = l["instance_type"]
-			}
+		// hourly_cost metric removed as it's deprecated. Cost is calculated in post-processing.
+		{"clustercost_node_cpu_usage_percent", true, func(e *store.NodeSummary, v float64, _ map[string]string) { e.CPUUsagePercent = v }},
+		{"clustercost_node_memory_usage_percent", true, func(e *store.NodeSummary, v float64, _ map[string]string) { e.MemoryUsagePercent = v }},
+		{"clustercost_node_cpu_allocatable_milli", true, func(e *store.NodeSummary, v float64, l map[string]string) {
+			e.CPUAllocatableMilli = int64(v)
+			updateMeta(e, l)
 		}},
-		{"clustercost_node_cpu_usage_percent", func(e *store.NodeSummary, v float64, _ map[string]string) { e.CPUUsagePercent = v }},
-		{"clustercost_node_memory_usage_percent", func(e *store.NodeSummary, v float64, _ map[string]string) { e.MemoryUsagePercent = v }},
-		{"clustercost_node_cpu_allocatable_milli", func(e *store.NodeSummary, v float64, _ map[string]string) { e.CPUAllocatableMilli = int64(v) }},
-		{"clustercost_node_memory_allocatable_bytes", func(e *store.NodeSummary, v float64, _ map[string]string) { e.MemoryAllocatableBytes = int64(v) }},
-		{"clustercost_node_pod_count", func(e *store.NodeSummary, v float64, _ map[string]string) { e.PodCount = int(v) }},
-		{"clustercost_node_under_pressure", func(e *store.NodeSummary, v float64, _ map[string]string) { e.IsUnderPressure = v > 0.5 }},
+		{"clustercost_node_memory_allocatable_bytes", true, func(e *store.NodeSummary, v float64, l map[string]string) {
+			e.MemoryAllocatableBytes = int64(v)
+			updateMeta(e, l)
+		}},
+		{"clustercost_node_cpu_requested_milli", true, func(e *store.NodeSummary, v float64, l map[string]string) {
+			e.CPURequestedMilli = int64(v)
+			updateMeta(e, l)
+		}},
+		{"clustercost_node_memory_requested_bytes", true, func(e *store.NodeSummary, v float64, l map[string]string) {
+			e.MemoryRequestedBytes = int64(v)
+			updateMeta(e, l)
+		}},
+		{"clustercost_node_cpu_limit_milli", true, func(e *store.NodeSummary, v float64, _ map[string]string) { e.CPULimitMilli = int64(v) }},
+		{"clustercost_node_memory_limit_bytes", true, func(e *store.NodeSummary, v float64, _ map[string]string) { e.MemoryLimitBytes = int64(v) }},
 	}
 
-	out := make(map[string]*store.NodeSummary)
 	for _, metric := range metrics {
 		by := "node"
-		if metric.name == "clustercost_node_hourly_cost" {
-			by = "node,instance_type"
+		// Preserve metadata labels in aggregation
+		if strings.Contains(metric.name, "requested") ||
+			strings.Contains(metric.name, "allocatable") {
+			by = "node,instance_type,node_label_node_kubernetes_io_instance_type,node_label_beta_kubernetes_io_instance_type,cluster_region,topology_kubernetes_io_region"
 		}
-		expr := fmt.Sprintf("max by (%s) (%s)", by, c.lookbackExpr(metric.name, labels, clusterID))
-		samples, err := c.query(ctx, expr)
+
+		// determine function
+		fn := lookbackFunc
+		// For cost, average over time gives the average hourly rate during that window.
+		// For usage %, average makes sense.
+		// For Requests/Limits/Allocatable, they might vary if node resized (rare) or replaced. Average is decent.
+
+		expr := fmt.Sprintf("%s(%s%s[%s])", fn, metric.name, formatLabels(c.scopedLabels(labels, clusterID)), windowStr)
+		// Need aggregation to preserve labels and unique by node
+		// max by (...) for snapshots, but avg by (...) for windows?
+		// Actually "avg by" works for all if we want the average stat.
+		aggOp := "avg"
+		if !strings.Contains(metric.name, "percent") && !strings.Contains(metric.name, "cost") {
+			// For allocatable/requests, max is often safer to see peak reservation?
+			// But for "Ghost Cost", average request is better?
+			// Let's stick to Average for Historical Analysis.
+			aggOp = "avg"
+		}
+
+		fullExpr := fmt.Sprintf("%s by (%s) (%s)", aggOp, by, expr)
+
+		samples, err := c.query(ctx, fullExpr)
 		if err != nil {
-			return nil, time.Time{}, err
+			continue // Skip failing metrics rather than crash whole request
 		}
+
 		for _, sample := range samples {
 			node := sample.labels["node"]
-			if node == "" {
-				continue
-			}
-			entry := out[node]
-			if entry == nil {
-				entry = &store.NodeSummary{
-					NodeName: node,
-					Labels:   map[string]string{},
-					Taints:   []string{},
-				}
-				out[node] = entry
+			entry := getOrCreate(node)
+			if entry != nil {
+				metric.assign(entry, sample.value, sample.labels)
 			}
-			metric.assign(entry, sample.value, sample.labels)
 		}
 	}
 
+	// 3. Post-Processing & Cost Backfill
+	var pricing *store.PricingCatalog
+	if c.pricing != nil {
+		pricing = c.pricing
+	} else {
+		// NewPricingCatalog now takes 0 args (static)
+		pricing = store.NewPricingCatalog()
+	}
+
+	// Fetch node status
 	statusSamples, err := c.seriesTimestamp(ctx, "clustercost_node_status", labels)
 	if err != nil && err != ErrNoData {
 		return nil, time.Time{}, err
@@ -851,7 +960,56 @@ func (c *Client) nodeMetrics(ctx context.Context, nodeName string) (map[string]*
 		}
 	}
 
-	latest := c.seriesTimestampSafe(ctx, "clustercost_node_hourly_cost")
+	for _, node := range out {
+		// Extract region from name fallback
+		if node.Labels["topology_kubernetes_io_region"] == "" {
+			re := regexp.MustCompile(`\.(us-[a-z]+-\d+)\.`)
+			matches := re.FindStringSubmatch(node.NodeName)
+			if len(matches) > 1 {
+				node.Labels["topology_kubernetes_io_region"] = matches[1]
+			}
+		}
+
+		region := node.Labels["topology_kubernetes_io_region"]
+		if region == "" {
+			// Fallback: Default region if unknown, often us-east-1 or inferred from node name
+			if strings.Contains(node.NodeName, "us-east-1") {
+				region = "us-east-1"
+			} else if strings.Contains(node.NodeName, "us-west-2") {
+				region = "us-west-2"
+			} else if strings.Contains(node.NodeName, "eu-west-1") {
+				region = "eu-west-1"
+			} else {
+				region = "us-east-1" // ultimate fallback
+			}
+		}
+
+		// Update region in labels so it persists
+		if node.Labels == nil {
+			node.Labels = map[string]string{}
+		}
+		node.Labels["topology_kubernetes_io_region"] = region
+
+		instanceType := node.InstanceType
+		if instanceType == "" {
+			instanceType = "m5.large" // Default fallback to avoid 0 cost
+		}
+
+		if node.HourlyCost == 0 {
+			node.HourlyCost = pricing.GetTotalNodePrice(context.Background(), region, instanceType)
+		}
+
+		// CALCULATE WINDOW COST / TOTAL COST
+		if windowDur > 0 {
+			// Real Cost = HourlyRate * ActiveHours
+			node.WindowCost = node.HourlyCost * node.ActiveHours
+		} else {
+			// Snapshot projection (Monthly)
+			node.WindowCost = node.HourlyCost * 730
+		}
+	}
+
+	latest := c.seriesTimestampSafe(ctx, "clustercost_node_cpu_allocatable_milli")
 	return out, latest, nil
 }
 
@@ -1026,7 +1184,7 @@ func pickLatestStatus(samples []sample) map[string]string {
 
 func (c *Client) nodeNames(ctx context.Context) []string {
 	clusterID := c.resolveClusterID(ctx)
-	expr := fmt.Sprintf("max by (node) (%s)", c.lookbackExpr("clustercost_node_hourly_cost", nil, clusterID))
+	expr := fmt.Sprintf("max by (node) (%s)", c.lookbackExpr("clustercost_node_cpu_allocatable_milli", nil, clusterID))
 	samples, err := c.query(ctx, expr)
 	if err != nil {
 		return nil
diff --git a/internal/vm/ingestor.go b/internal/vm/ingestor.go
index 5ba8fee..d2aab8f 100644
--- a/internal/vm/ingestor.go
+++ b/internal/vm/ingestor.go
@@ -325,7 +325,7 @@ func (i *Ingestor) appendMetricsReport(buf, labelBuf *bytes.Buffer, scratch []by
 	}
 	// map[namespace]*nsAgg
 	nsMap := make(map[string]*nsAgg)
-	pricing := store.NewPricingCatalog(nil)
+	pricing := store.NewPricingCatalog()
 	region := req.Region
 	if region == "" {
 		region = req.AvailabilityZone
@@ -534,6 +534,14 @@ func (i *Ingestor) appendMetricsReport(buf, labelBuf *bytes.Buffer, scratch []by
 			writeFloatSample(buf, scratch, "clustercost_node_memory_usage_percent", nodeLabelsBlob, memPct, tsMillis)
 		}
 
+		// Calculate Node Hourly Cost
+		// We use Capacity because you pay for the whole node, not just allocatable.
+		nodeCpuCores := float64(node.CapacityCpuMillicores) / 1000.0
+		nodeMemGB := float64(node.CapacityMemoryBytes) / (1024 * 1024 * 1024)
+		nodeHourlyCost := (nodeCpuCores * cpuPrice) + (nodeMemGB * memPrice)
+
+		writeFloatSample(buf, scratch, "clustercost_node_hourly_cost", nodeLabelsBlob, nodeHourlyCost, tsMillis)
+
 		// Node Network Metrics (Host Traffic)
 		if node.Network != nil {
 			nodeTx := safeInt64(node.Network.BytesSent)
diff --git a/web/package-lock.json b/web/package-lock.json
index 227b0d7..39dceb8 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -14,6 +14,7 @@
         "@radix-ui/react-select": "^2.2.6",
         "@radix-ui/react-slot": "^1.2.4",
         "@radix-ui/react-tabs": "^1.1.13",
+        "@radix-ui/react-tooltip": "^1.2.8",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "lucide-react": "^0.298.0",
@@ -35,6 +36,7 @@
         "@types/react-dom": "^18.2.7",
         "@vitejs/plugin-react": "^4.2.1",
         "autoprefixer": "^10.4.16",
+        "baseline-browser-mapping": "^2.9.15",
         "jsdom": "^24.0.0",
         "postcss": "^8.4.31",
         "tailwindcss": "^3.4.14",
@@ -1709,6 +1711,58 @@
         }
       }
     },
+    "node_modules/@radix-ui/react-tooltip": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz",
+      "integrity": "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/primitive": "1.1.3",
+        "@radix-ui/react-compose-refs": "1.1.2",
+        "@radix-ui/react-context": "1.1.2",
+        "@radix-ui/react-dismissable-layer": "1.1.11",
+        "@radix-ui/react-id": "1.1.1",
+        "@radix-ui/react-popper": "1.2.8",
+        "@radix-ui/react-portal": "1.1.9",
+        "@radix-ui/react-presence": "1.1.5",
+        "@radix-ui/react-primitive": "2.1.3",
+        "@radix-ui/react-slot": "1.2.3",
+        "@radix-ui/react-use-controllable-state": "1.2.2",
+        "@radix-ui/react-visually-hidden": "1.2.3"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "@types/react-dom": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@radix-ui/react-tooltip/node_modules/@radix-ui/react-slot": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+      "license": "MIT",
+      "dependencies": {
+        "@radix-ui/react-compose-refs": "1.1.2"
+      },
+      "peerDependencies": {
+        "@types/react": "*",
+        "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@radix-ui/react-use-callback-ref": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
@@ -3047,9 +3101,9 @@
       "license": "MIT"
     },
     "node_modules/baseline-browser-mapping": {
-      "version": "2.8.28",
-      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.28.tgz",
-      "integrity": "sha512-gYjt7OIqdM0PcttNYP2aVrr2G0bMALkBaoehD4BuRGjAOtipg0b6wHg1yNL+s5zSnLZZrGHOw4IrND8CD+3oIQ==",
+      "version": "2.9.15",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.9.15.tgz",
+      "integrity": "sha512-kX8h7K2srmDyYnXRIppo4AH/wYgzWVCs+eKr3RusRSQ5PvRYoEFmR/I0PbdTjKFAoKqp5+kbxnNTFO9jOfSVJg==",
       "dev": true,
       "license": "Apache-2.0",
       "bin": {
diff --git a/web/package.json b/web/package.json
index 5daf043..9ee6cae 100644
--- a/web/package.json
+++ b/web/package.json
@@ -17,13 +17,14 @@
     "@radix-ui/react-select": "^2.2.6",
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-tooltip": "^1.2.8",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^0.298.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "reactflow": "^11.11.4",
     "react-router-dom": "^6.20.0",
+    "reactflow": "^11.11.4",
     "recharts": "^2.8.0",
     "shadcn-ui": "^0.9.5",
     "tailwind-merge": "^1.14.0",
@@ -38,6 +39,7 @@
     "@types/react-dom": "^18.2.7",
     "@vitejs/plugin-react": "^4.2.1",
     "autoprefixer": "^10.4.16",
+    "baseline-browser-mapping": "^2.9.15",
     "jsdom": "^24.0.0",
     "postcss": "^8.4.31",
     "tailwindcss": "^3.4.14",
diff --git a/web/src/components/common/MetricCard.tsx b/web/src/components/common/MetricCard.tsx
new file mode 100644
index 0000000..83c7e7c
--- /dev/null
+++ b/web/src/components/common/MetricCard.tsx
@@ -0,0 +1,39 @@
+import { Card, CardContent, CardHeader, CardTitle } from "../ui/card";
+import { cn } from "../../lib/utils";
+
+interface MetricCardProps {
+    title: string;
+    value: string;
+    subtext?: string;
+    trend?: string;
+    trendUp?: boolean;
+    className?: string;
+    valueClassName?: string;
+}
+
+export function MetricCard({ title, value, subtext, trend, trendUp, className, valueClassName }: MetricCardProps) {
+    return (
+        <Card className={cn("bg-card/50 backdrop-blur-sm border-muted/50", className)}>
+            <CardHeader className="p-4 pb-2 space-y-0">
+                <CardTitle className="text-xs font-medium text-muted-foreground uppercase tracking-wider">
+                    {title}
+                </CardTitle>
+            </CardHeader>
+            <CardContent className="p-4 pt-0">
+                <div className={cn("text-2xl font-bold font-mono tracking-tight", valueClassName)}>
+                    {value}
+                </div>
+                {(subtext || trend) && (
+                    <div className="mt-1 flex items-center text-xs text-muted-foreground">
+                        {trend && (
+                            <span className={cn("mr-2 font-medium", trendUp ? "text-emerald-500" : "text-rose-500")}>
+                                {trend}
+                            </span>
+                        )}
+                        {subtext}
+                    </div>
+                )}
+            </CardContent>
+        </Card>
+    );
+}
diff --git a/web/src/components/nodes/EfficiencyBar.tsx b/web/src/components/nodes/EfficiencyBar.tsx
new file mode 100644
index 0000000..991aa08
--- /dev/null
+++ b/web/src/components/nodes/EfficiencyBar.tsx
@@ -0,0 +1,183 @@
+import { Badge } from "@/components/ui/badge";
+import { formatCurrency } from "../../lib/utils";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
+import { AlertTriangle, CheckCircle2, TrendingDown } from "lucide-react";
+
+interface EfficiencyBarProps {
+    usagePercent: number;
+    requestPercent: number;
+    costPerMonth: number;
+    usageAbsolute: number;
+    totalAbsolute: number;
+    unit: string;
+}
+
+export function EfficiencyBar({
+    usagePercent,
+    requestPercent,
+    costPerMonth,
+    usageAbsolute,
+    totalAbsolute,
+    unit
+}: EfficiencyBarProps) {
+    // FinOps Logic:
+    // "Comfort Zone" Strategy:
+    // - Container = Total Node Capacity
+    // - Reserved = Light Rail (bg-white/15)
+    // - Threshold = White Line (Always visible on top)
+    // - Logic:
+    //   - < 90% of Reserved: Gap (Cyan)
+    //   - 90% - 110% of Reserved: Optimized (Green Badge, Cyan Bar)
+    //   - > 110% of Reserved: Risk (Orange Bar, Orange Text)
+
+    const ratio = requestPercent > 0 ? usagePercent / requestPercent : 0;
+
+    // Logic Refinement (Hybrid Absolute/Relative):
+    // 1. High Risk (Orange): STRICTLY > 110% of reservation (Relative > 1.1).
+    // 2. Optimized (Green): Not High Risk AND Absolute Difference <= 10% (suppress "Gap: 3%" noise).
+    // 3. Gap (Cyan): Everything else (Absolute Difference > 10%).
+
+    const isHighRisk = ratio > 1.1;
+    const diff = Math.abs(usagePercent - requestPercent);
+    const isOptimized = !isHighRisk && diff <= 10;
+
+    const wastePercent = Math.max(0, requestPercent - usagePercent);
+    const overflowPercent = Math.max(0, usagePercent - requestPercent);
+    const wastedCost = costPerMonth * (wastePercent / 100);
+
+    return (
+        <div className="w-full min-w-[140px] flex flex-col gap-1 py-1">
+            {/* Micro-Text Label Row */}
+            <div className="flex justify-between items-end px-0.5 font-mono">
+                <span className="text-[10px] text-muted-foreground">
+                    <span className="font-bold text-foreground">{usageAbsolute.toFixed(1)}</span>
+                    <span className="opacity-70"> / {totalAbsolute.toFixed(1)} {unit}</span>
+                </span>
+
+                {/* Status Indicator */}
+                {isOptimized ? (
+                    <Badge variant="outline" className="text-[9px] h-3.5 px-1.5 py-0 border-emerald-500/40 text-emerald-500 bg-emerald-500/5 hover:bg-emerald-500/10 font-sans tracking-wide">
+                        Optimized
+                    </Badge>
+                ) : isHighRisk ? (
+                    <span className="text-[10px] text-orange-500 font-bold tracking-tight">
+                        Risk: +{overflowPercent.toFixed(0)}%
+                    </span>
+                ) : wastePercent > 0 ? (
+                    <span className="text-[10px] text-cyan-500 font-bold tracking-tight">
+                        Gap: {wastePercent.toFixed(0)}%
+                    </span>
+                ) : null}
+            </div>
+
+            {/* Bar Container */}
+            <TooltipProvider delayDuration={0}>
+                <Tooltip>
+                    <TooltipTrigger asChild>
+                        {/* Layer 0: Total Capacity Container */}
+                        <div className="relative h-3 w-full bg-muted/10 rounded-sm overflow-hidden cursor-help ring-1 ring-white/5">
+
+                            {/* Layer 1: Reserved (The Contract Rail) */}
+                            {/* Lighter grey to contrast with dark background */}
+                            <div
+                                className="absolute top-0 left-0 h-full bg-white/15 z-0"
+                                style={{ width: `${Math.min(requestPercent, 100)}%` }}
+                            />
+
+                            {/* Layer 2: Actual Usage (The Active Liquid) */}
+                            {/* Sits ON TOP of Reserved. */}
+                            <div
+                                className={`absolute top-0 left-0 h-full shadow-sm z-10 transition-all duration-500 ${isHighRisk ? "bg-orange-500 shadow-[0_0_12px_rgba(249,115,22,0.6)]" : "bg-cyan-500 shadow-[0_0_8px_rgba(6,182,212,0.6)]"}`}
+                                style={{ width: `${Math.min(usagePercent, 100)}%` }}
+                            />
+
+                            {/* Layer 3: The Contract Line (Threshold) */}
+                            {/* ALWAYS visible, white, sits on top of everything (z-20) */}
+                            {requestPercent > 0 && (
+                                <div
+                                    className="absolute top-0 h-full w-[1.5px] bg-white z-20 shadow-[0_0_2px_rgba(0,0,0,0.5)]"
+                                    style={{ left: `${Math.min(requestPercent, 100)}%` }}
+                                />
+                            )}
+                        </div>
+                    </TooltipTrigger>
+
+                    {/* Professional Context Card Tooltip */}
+                    <TooltipContent
+                        side="bottom"
+                        className={`w-[260px] p-0 bg-slate-950/95 backdrop-blur-xl border-2 ${isHighRisk ? 'border-orange-500/50' : isOptimized ? 'border-emerald-500/50' : 'border-cyan-500/50'} shadow-2xl`}
+                    >
+                        <div className="p-3 space-y-3">
+                            {/* Header Section */}
+                            <div className="flex items-start gap-2 border-b border-white/5 pb-2">
+                                {isHighRisk ? (
+                                    <AlertTriangle className="w-4 h-4 text-orange-500 mt-0.5" />
+                                ) : isOptimized ? (
+                                    <CheckCircle2 className="w-4 h-4 text-emerald-500 mt-0.5" />
+                                ) : (
+                                    <TrendingDown className="w-4 h-4 text-cyan-500 mt-0.5" />
+                                )}
+                                <div>
+                                    <p className={`text-sm font-bold ${isHighRisk ? 'text-orange-500' : isOptimized ? 'text-emerald-500' : 'text-cyan-400'}`}>
+                                        {isHighRisk ? "Stability Risk: Bursting" : isOptimized ? "Perfectly Rightsized" : "Efficiency Gap Detected"}
+                                    </p>
+                                    <p className="text-[10px] text-slate-400 leading-tight mt-0.5">
+                                        {isHighRisk
+                                            ? "Operating above guaranteed limits."
+                                            : isOptimized
+                                                ? "Balanced resource utilization."
+                                                : "Resources reserved but unused."}
+                                    </p>
+                                </div>
+                            </div>
+
+                            {/* Technical Evidence Section */}
+                            <div className="bg-slate-900/50 rounded p-2 space-y-1 font-mono text-[10px]">
+                                <div className="flex justify-between text-slate-300">
+                                    <span>Usage:</span>
+                                    <span className={isHighRisk ? "text-orange-400 font-bold" : "text-cyan-400 font-bold"}>
+                                        {usagePercent.toFixed(1)}% ({usageAbsolute.toFixed(2)} {unit})
+                                    </span>
+                                </div>
+                                <div className="flex justify-between text-slate-400">
+                                    <span>Reserved:</span>
+                                    <span>{requestPercent.toFixed(1)}% ({((totalAbsolute * requestPercent) / 100 || 0).toFixed(2)} {unit})</span>
+                                </div>
+                            </div>
+
+                            {/* Educational Context Section */}
+                            <div className="text-[11px] text-slate-300 leading-relaxed">
+                                {isHighRisk && (
+                                    <span>
+                                        This node is running at <strong className="text-orange-400">{ratio.toFixed(2)}x</strong> its reservation.
+                                        It relies on unguaranteed burst capacity and is a top candidate for <strong className="text-white bg-red-900/30 px-1 rounded">OOMKill</strong> if cluster pressure increases.
+                                    </span>
+                                )}
+                                {isOptimized && (
+                                    <span>
+                                        Usage is within the <strong className="text-emerald-400">±10% ideal stability window</strong>.
+                                        This configuration maximizes ROI without risking instability. No action required.
+                                    </span>
+                                )}
+                                {!isHighRisk && !isOptimized && (
+                                    <span>
+                                        You are paying for <strong className="text-cyan-400">{(requestPercent - usagePercent).toFixed(0)}%</strong> more capacity than needed.
+                                        This "air gap" provides no technical value and is pure <strong className="text-white border-b border-red-500/50">financial waste</strong>.
+                                    </span>
+                                )}
+                            </div>
+
+                            {/* Financial Impact Footer */}
+                            {!isOptimized && wastedCost > 0.01 && (
+                                <div className="pt-2 border-t border-white/5 flex justify-between items-center">
+                                    <span className="text-[10px] text-slate-500 uppercase tracking-wider font-bold">Monthly Waste</span>
+                                    <span className="text-xs font-mono font-bold text-red-400">{formatCurrency(wastedCost)}</span>
+                                </div>
+                            )}
+                        </div>
+                    </TooltipContent>
+                </Tooltip>
+            </TooltipProvider>
+        </div>
+    );
+}
diff --git a/web/src/components/nodes/NodeDetailSheet.tsx b/web/src/components/nodes/NodeDetailSheet.tsx
index 45a5e79..ceae404 100644
--- a/web/src/components/nodes/NodeDetailSheet.tsx
+++ b/web/src/components/nodes/NodeDetailSheet.tsx
@@ -1,8 +1,14 @@
-import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "../ui/sheet";
-import { Progress } from "../ui/progress";
-import { Badge } from "../ui/badge";
+import { Sheet, SheetContent, SheetHeader, SheetTitle } from "@/components/ui/sheet";
+import { Progress } from "@/components/ui/progress";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
 import { formatCurrency } from "../../lib/utils";
-import type { NodeCost } from "../../lib/api";
+import { fetchNodeStats, fetchNodePods, type NodeCost, type NodeStats, type PodMetrics } from "../../lib/api";
+import { useState, useEffect, useMemo } from "react";
+import { CopyIcon, ShieldAlertIcon, ScissorsIcon, CheckCircle2Icon } from "lucide-react";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 
 interface NodeDetailSheetProps {
   node: (NodeCost & { monthlyCost: number }) | null;
@@ -10,75 +16,277 @@ interface NodeDetailSheetProps {
   onOpenChange: (open: boolean) => void;
 }
 
-const statusStyles: Record<NodeCost["status"], string> = {
-  Ready: "border-emerald-500/40 bg-emerald-500/10 text-emerald-200",
-  NotReady: "border-destructive/40 bg-destructive/10 text-destructive",
-  Unknown: "border-muted bg-muted/40 text-muted-foreground"
-};
-
 const NodeDetailSheet = ({ node, open, onOpenChange }: NodeDetailSheetProps) => {
+  const [window, setWindow] = useState("24h");
+  const [stats, setStats] = useState<NodeStats | null>(null);
+  const [pods, setPods] = useState<PodMetrics[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    if (open && node) {
+      setLoading(true);
+      // Parallel Fetch: Stats + Pods
+      Promise.all([
+        fetchNodeStats(node.nodeName, window).catch(e => { console.error(e); return null; }),
+        fetchNodePods(node.nodeName, window).catch(e => { console.error(e); return []; })
+      ]).then(([statsData, podsData]) => {
+        setStats(statsData);
+        setPods(podsData || []);
+        setLoading(false);
+      });
+    } else {
+      setStats(null);
+      setPods([]);
+    }
+  }, [open, node, window]);
+
+  const copyToClipboard = (text: string) => {
+    navigator.clipboard.writeText(text);
+  };
+
+  const getRec = (p95: number) => Math.ceil(p95 * 1.15); // P95 + 15%
+
+  const generatePatch = (pod: PodMetrics, type: "cpu" | "memory" | "both", reason: "fix" | "shield") => {
+    const rawCpu = getRec(pod.cpuP95Milli);
+    // Ensure we don't go below 10m for CPU to be safe
+    const targetCpu = Math.max(10, rawCpu);
+    const targetCpuStr = `${targetCpu}m`;
+
+    const rawMem = getRec(pod.memoryP95Bytes);
+    // Convert to Mi
+    const targetMemMi = Math.ceil(rawMem / (1024 * 1024));
+    const targetMemStr = `${targetMemMi}Mi`;
+
+    const resources: any = { requests: {} };
+    if (type === "cpu" || type === "both") resources.requests.cpu = targetCpuStr;
+    if (type === "memory" || type === "both") resources.requests.memory = targetMemStr;
+
+    // Use container name approximation or index 0 for now as we don't have container name in PodMetrics yet.
+    // Using simple approach: Assume first container needs fix found in spec.
+    // Actually we need the container name. Backend aggregates by pod...
+    // For now we will use pod name prefix as best effort, or just "name".
+    // A better approach is usually `kubectl set resources` or patch assuming single container or main container.
+    // Let's use the first container approach in the patch for now: `spec: { containers: [ { name: "?", ... } ] }`.
+    // Wait, we don't know the container name. 
+    // To make this robust without container name, we can try to patch by index `containers[0]`.
+    // JSON Patch: `[{"op": "replace", "path": "/spec/containers/0/resources/requests/cpu", "value": "..."}]`
+    // But let's stick to the user's requested text format: `kubectl patch ...`
+    // We will use `deployment` logic usually, but here we patch the POD? Pods are ephemeral.
+    // Ideally we patch the deployment.
+    // User asked for "Fix YAML".
+    const containerName = pod.podName.split("-")[0]; // Heuristic
+
+    return `kubectl patch pod ${pod.podName} -n ${pod.namespace} --patch '{"spec":{"containers":[{"name":"${containerName}", "resources":{"requests":{"cpu":"${targetCpuStr}","memory":"${targetMemStr}"}}}]}}'`;
+  };
+
   if (!node) return null;
 
-  const statusBadge = (
-    <Badge variant="outline" className={statusStyles[node.status]}>
-      {node.status}
-    </Badge>
-  );
+  // SORTING LOGIC: Financial Impact (Savings First)
+  // Heuristic: ~$32/vCPU/mo, ~$4/GB/mo
+  const COST_PER_VCPU = 32;
+  const COST_PER_GB = 4;
 
-  const usageSummary = (() => {
-    if (node.cpuUsagePercent > 70 || node.memoryUsagePercent > 70) return "Node is heavily used.";
-    if (node.cpuUsagePercent < 30 && node.memoryUsagePercent < 30) return "This node is mostly idle.";
-    return "Usage looks normal.";
-  })();
+  const getSavings = (pod: PodMetrics) => {
+    const cpuRec = getRec(pod.cpuP95Milli);
+    const cpuWasteCores = (pod.cpuRequestMilli - cpuRec) / 1000;
+    const cpuSavings = cpuWasteCores * COST_PER_VCPU;
+
+    const memRec = getRec(pod.memoryP95Bytes);
+    const memWasteGB = (pod.memoryRequestBytes - memRec) / (1024 * 1024 * 1024);
+    const memSavings = memWasteGB * COST_PER_GB;
+
+    return cpuSavings + memSavings;
+  };
+
+  const sortedPods = [...pods].sort((a, b) => {
+    return getSavings(b) - getSavings(a); // Descending (Biggest Savings First)
+  });
 
   return (
     <Sheet open={open} onOpenChange={onOpenChange}>
-      <SheetContent className="w-full sm:max-w-md">
-        <SheetHeader>
+      <SheetContent className="w-full sm:max-w-2xl p-0 gap-0 overflow-hidden bg-background text-foreground flex flex-col">
+        {/* HEADER */}
+        <SheetHeader className="p-6 border-b border-border/40 bg-muted/5 space-y-4">
           <SheetTitle className="flex flex-col gap-1">
-            <span className="text-lg font-semibold">{node.nodeName}</span>
-            <span className="text-sm text-muted-foreground">
-              {(node.instanceType ?? "Unknown type")} · {node.podCount} pods
-            </span>
+            <span className="text-xs font-mono text-muted-foreground">{node.nodeName}</span>
+            <div className="flex items-center gap-2">
+              <span className="text-lg font-bold">{node.instanceType}</span>
+              <Badge variant="outline" className="text-[10px] h-5">{node.podCount} Pods</Badge>
+            </div>
           </SheetTitle>
-          <SheetDescription className="flex items-center gap-2">
-            {statusBadge}
-            {node.isUnderPressure && <Badge variant="destructive">Under pressure</Badge>}
-          </SheetDescription>
-        </SheetHeader>
-
-        <div className="mt-6 space-y-5 text-sm">
-          <section>
-            <p className="text-xs uppercase text-muted-foreground">Monthly cost</p>
-            <p className="text-2xl font-semibold">{formatCurrency(node.monthlyCost)}</p>
-            <p className="text-xs text-muted-foreground">{formatCurrency(node.hourlyCost, { maximumFractionDigits: 2 })}/hr</p>
-          </section>
-
-          <section className="space-y-3">
-            <div>
-              <div className="flex items-center justify-between text-xs text-muted-foreground">
-                <span>CPU usage</span>
-                <span>{node.cpuUsagePercent.toFixed(0)}%</span>
-              </div>
-              <Progress value={node.cpuUsagePercent} className="mt-2" />
+          <div className="grid grid-cols-2 gap-4">
+            <div className="p-3 rounded-lg border bg-card/50">
+              <p className="text-[10px] uppercase tracking-wider text-muted-foreground">Monthly Cost</p>
+              <p className="text-2xl font-bold">{formatCurrency(node.monthlyCost)}</p>
             </div>
-            <div>
-              <div className="flex items-center justify-between text-xs text-muted-foreground">
-                <span>Memory usage</span>
-                <span>{node.memoryUsagePercent.toFixed(0)}%</span>
-              </div>
-              <Progress value={node.memoryUsagePercent} className="mt-2" />
+            <div className={`p-3 rounded-lg border bg-card/50 ${stats && stats.totalMonthlyCost - stats.realUsageMonthlyCost > stats.totalMonthlyCost * 0.1 ? "border-emerald-500/20 bg-emerald-500/5 text-emerald-500" : "text-muted-foreground"}`}>
+              <p className="text-[10px] uppercase tracking-wider text-muted-foreground">Potential Savings</p>
+              <p className="text-2xl font-bold">
+                {stats ? formatCurrency(stats.totalMonthlyCost - stats.realUsageMonthlyCost) : "..."}
+              </p>
             </div>
-          </section>
+          </div>
+        </SheetHeader>
+
+        <SectionTabs window={window} setWindow={setWindow} />
+
+        <div className="flex-1 overflow-auto">
+          <div className="p-6 space-y-8">
+            {/* P95 METRICS */}
+            {stats && (
+              <section className="space-y-4">
+                <h3 className="text-xs font-bold uppercase tracking-wider text-muted-foreground">Node P95 Analysis ({window})</h3>
+                <div className="grid grid-cols-2 gap-4">
+                  <div>
+                    <div className="flex justify-between text-xs mb-1.5">
+                      <span>CPU P95 Load</span>
+                      <span className="font-mono">{stats.p95CpuUsagePercent.toFixed(1)}%</span>
+                    </div>
+                    <Progress value={stats.p95CpuUsagePercent} className="h-2" />
+                  </div>
+                  <div>
+                    <div className="flex justify-between text-xs mb-1.5">
+                      <span>Memory P95 Load</span>
+                      <span className="font-mono">{stats.p95MemoryUsagePercent.toFixed(1)}%</span>
+                    </div>
+                    <Progress value={stats.p95MemoryUsagePercent} className="h-2" />
+                  </div>
+                </div>
+              </section>
+            )}
+
+            {/* FULL AUDIT TABLE */}
+            <section className="space-y-4">
+              <h3 className="text-xs font-bold uppercase tracking-wider text-muted-foreground">Full Pod Audit (P95 + 15% Safety Margin)</h3>
+              <div className="rounded-md border">
+                <Table>
+                  <TableHeader className="bg-muted/30">
+                    <TableRow>
+                      <TableHead className="text-xs w-[180px]">Pod (QoS)</TableHead>
+                      <TableHead className="text-xs text-right">CPU (Req → P95)</TableHead>
+                      <TableHead className="text-xs text-right">RAM (Req → P95)</TableHead>
+                      <TableHead className="text-xs text-right">Action</TableHead>
+                    </TableRow>
+                  </TableHeader>
+                  <TableBody>
+                    {loading ? (
+                      <TableRow>
+                        <TableCell colSpan={4} className="text-center py-8 text-muted-foreground text-xs animate-pulse">
+                          Analyzing pod logs & metrics...
+                        </TableCell>
+                      </TableRow>
+                    ) : pods.length === 0 ? (
+                      <TableRow>
+                        <TableCell colSpan={4} className="text-center py-8 text-muted-foreground text-xs">
+                          No pods found or agent not reporting deep metrics yet.
+                        </TableCell>
+                      </TableRow>
+                    ) : (
+                      sortedPods.map(pod => {
+                        // CPU Analysis
+                        const cpuRec = getRec(pod.cpuP95Milli);
+                        const cpuDiff = cpuRec - pod.cpuRequestMilli;
+                        const cpuRisk = pod.cpuP95Milli > pod.cpuRequestMilli;
+                        const cpuOptimized = !cpuRisk && Math.abs(cpuDiff) <= (0.1 * pod.cpuRequestMilli);
 
-          <section>
-            <p className="text-xs uppercase text-muted-foreground">Status</p>
-            <p className="text-sm">{usageSummary}</p>
-          </section>
+                        // MEM Analysis
+                        const memRec = getRec(pod.memoryP95Bytes);
+                        const memDiff = memRec - pod.memoryRequestBytes;
+                        const memRisk = pod.memoryP95Bytes > pod.memoryRequestBytes;
+                        const memOptimized = !memRisk && Math.abs(memDiff) <= (0.1 * pod.memoryRequestBytes);
+
+                        // Global State
+                        const isRisk = cpuRisk || memRisk;
+                        const isOptimized = cpuOptimized && memOptimized;
+
+                        const cpuReqStr = `${pod.cpuRequestMilli}m`;
+                        const cpuP95Str = `${pod.cpuP95Milli.toFixed(0)}m`;
+                        const memReqStr = `${(pod.memoryRequestBytes / (1024 * 1024)).toFixed(0)}Mi`;
+                        const memP95Str = `${(pod.memoryP95Bytes / (1024 * 1024)).toFixed(0)}Mi`;
+
+                        return (
+                          <TableRow key={pod.namespace + pod.podName}>
+                            <TableCell>
+                              <div className="flex flex-col">
+                                <span className="font-mono text-xs font-semibold truncate max-w-[140px]" title={pod.podName}>{pod.podName}</span>
+                                <span className="text-[10px] text-muted-foreground">{pod.namespace}</span>
+                                <span className="text-[9px] text-slate-500 uppercase">{pod.qosClass}</span>
+                              </div>
+                            </TableCell>
+
+                            <TableCell className="text-right">
+                              <div className="flex flex-col items-end gap-0.5">
+                                <span className={`text-xs font-mono ${cpuRisk ? "text-orange-500 font-bold" : "text-muted-foreground"}`}>
+                                  {cpuReqStr} → {cpuP95Str}
+                                </span>
+                                {cpuRisk && <span className="text-[10px] text-orange-500 font-bold">RISK</span>}
+                                {!cpuRisk && !cpuOptimized && <span className="text-[10px] text-cyan-500">Waste</span>}
+                              </div>
+                            </TableCell>
+
+                            <TableCell className="text-right">
+                              <div className="flex flex-col items-end gap-0.5">
+                                <span className={`text-xs font-mono ${memRisk ? "text-orange-500 font-bold" : "text-muted-foreground"}`}>
+                                  {memReqStr} → {memP95Str}
+                                </span>
+                                {memRisk && <span className="text-[10px] text-orange-500 font-bold">RISK</span>}
+                                {!memRisk && !memOptimized && <span className="text-[10px] text-cyan-500">Waste</span>}
+                              </div>
+                            </TableCell>
+
+                            <TableCell className="text-right">
+                              {isOptimized ? (
+                                <Badge variant="secondary" className="bg-emerald-500/10 text-emerald-500 border-0 text-[10px]">
+                                  <CheckCircle2Icon className="w-3 h-3 mr-1" /> Optimized
+                                </Badge>
+                              ) : (
+                                <TooltipProvider>
+                                  <Tooltip>
+                                    <TooltipTrigger asChild>
+                                      <Button
+                                        variant="outline"
+                                        size="sm"
+                                        className={`h-7 text-[10px] gap-1 ${isRisk
+                                          ? "border-orange-500/50 text-orange-500 hover:bg-orange-500/10"
+                                          : "border-cyan-500/50 text-cyan-500 hover:bg-cyan-500/10"}`}
+                                        onClick={() => copyToClipboard(generatePatch(pod, "both", isRisk ? "shield" : "fix"))}
+                                      >
+                                        {isRisk ? <ShieldAlertIcon className="w-3 h-3" /> : <ScissorsIcon className="w-3 h-3" />}
+                                        {isRisk ? "Shield Pod" : "Fix YAML"}
+                                      </Button>
+                                    </TooltipTrigger>
+                                    <TooltipContent>
+                                      Copy {isRisk ? "Upsize" : "Downsize"} Patch (CPU & RAM)
+                                    </TooltipContent>
+                                  </Tooltip>
+                                </TooltipProvider>
+                              )}
+                            </TableCell>
+                          </TableRow>
+                        );
+                      })
+                    )}
+                  </TableBody>
+                </Table>
+              </div>
+            </section>
+          </div>
         </div>
       </SheetContent>
     </Sheet>
   );
 };
 
+const SectionTabs = ({ window, setWindow }: { window: string; setWindow: (w: string) => void }) => (
+  <div className="px-6">
+    <Tabs value={window} onValueChange={setWindow} className="w-full">
+      <TabsList className="grid w-full grid-cols-3 h-8 bg-muted/30">
+        <TabsTrigger value="24h" className="text-xs h-6">24h</TabsTrigger>
+        <TabsTrigger value="7d" className="text-xs h-6">7d</TabsTrigger>
+        <TabsTrigger value="30d" className="text-xs h-6">30d</TabsTrigger>
+      </TabsList>
+    </Tabs>
+  </div>
+);
+
 export default NodeDetailSheet;
diff --git a/web/src/components/ui/progress.tsx b/web/src/components/ui/progress.tsx
index 3fd47ad..54d2611 100644
--- a/web/src/components/ui/progress.tsx
+++ b/web/src/components/ui/progress.tsx
@@ -5,8 +5,8 @@ import { cn } from "@/lib/utils"
 
 const Progress = React.forwardRef<
   React.ElementRef<typeof ProgressPrimitive.Root>,
-  React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>
->(({ className, value, ...props }, ref) => (
+  React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> & { indicatorClassName?: string }
+>(({ className, indicatorClassName, value, ...props }, ref) => (
   <ProgressPrimitive.Root
     ref={ref}
     className={cn(
@@ -16,7 +16,7 @@ const Progress = React.forwardRef<
     {...props}
   >
     <ProgressPrimitive.Indicator
-      className="h-full w-full flex-1 bg-primary transition-all"
+      className={cn("h-full w-full flex-1 bg-primary transition-all", indicatorClassName)}
       style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
     />
   </ProgressPrimitive.Root>
diff --git a/web/src/components/ui/tooltip.tsx b/web/src/components/ui/tooltip.tsx
new file mode 100644
index 0000000..b0542cb
--- /dev/null
+++ b/web/src/components/ui/tooltip.tsx
@@ -0,0 +1,28 @@
+import * as React from "react"
+import * as TooltipPrimitive from "@radix-ui/react-tooltip"
+
+import { cn } from "../../lib/utils"
+
+const TooltipProvider = TooltipPrimitive.Provider
+
+const Tooltip = TooltipPrimitive.Root
+
+const TooltipTrigger = TooltipPrimitive.Trigger
+
+const TooltipContent = React.forwardRef<
+    React.ElementRef<typeof TooltipPrimitive.Content>,
+    React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
+>(({ className, sideOffset = 4, ...props }, ref) => (
+    <TooltipPrimitive.Content
+        ref={ref}
+        sideOffset={sideOffset}
+        className={cn(
+            "z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+            className
+        )}
+        {...props}
+    />
+))
+TooltipContent.displayName = TooltipPrimitive.Content.displayName
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }
diff --git a/web/src/lib/api.ts b/web/src/lib/api.ts
index 3805d12..e0f4596 100644
--- a/web/src/lib/api.ts
+++ b/web/src/lib/api.ts
@@ -1,6 +1,9 @@
 import type { Environment } from "./utils";
 
-const API_PREFIX = "/api";
+// Allow overriding the API base via env var (useful for production builds or direct CORS)
+// If VITE_API_URL is set (e.g. "https://api.example.com"), we use that. 
+// Otherwise default to local proxy "/api".
+const API_PREFIX = import.meta.env.VITE_API_URL || "/api";
 
 const normalizeEnvironment = (value?: string): Environment => {
   switch ((value || "").toLowerCase()) {
@@ -110,8 +113,15 @@ export interface NamespacesResponse {
 type NodeCostApi = {
   nodeName: string;
   hourlyCost: number;
+  windowCost: number;
+  activeHours: number;
+  activeRatio: number;
   cpuUsagePercent: number;
   memoryUsagePercent: number;
+  cpuRequestedMilli?: number;
+  cpuLimitMilli?: number;
+  memoryRequestedBytes?: number;
+  memoryLimitBytes?: number;
   cpuAllocatableMilli?: number;
   memoryAllocatableBytes?: number;
   podCount: number;
@@ -331,8 +341,9 @@ export const fetchNamespaces = async (): Promise<NamespacesResponse> => {
   };
 };
 
-export const fetchNodes = async (): Promise<NodeCost[]> => {
-  const resp = await request<NodeListApiResponse>("/cost/nodes");
+export const fetchNodes = async (window?: string): Promise<NodeCost[]> => {
+  const query = window ? `?window=${window}` : "";
+  const resp = await request<NodeListApiResponse>(`/cost/nodes${query}`);
   return resp.items.map((node) => ({
     ...node,
     labels: node.labels ?? {},
@@ -341,6 +352,33 @@ export const fetchNodes = async (): Promise<NodeCost[]> => {
   }));
 };
 
+export interface NodeStats {
+  nodeName: string;
+  p95CpuUsagePercent: number;
+  p95MemoryUsagePercent: number;
+  totalMonthlyCost: number;
+  realUsageMonthlyCost: number;
+  window: string;
+}
+
+export const fetchNodeStats = async (name: string, window: string): Promise<NodeStats> => {
+  return request<NodeStats>(`/cost/nodes/${name}/stats?window=${window}`);
+};
+
+export interface PodMetrics {
+  podName: string;
+  namespace: string;
+  qosClass: string;
+  cpuRequestMilli: number;
+  cpuP95Milli: number;
+  memoryRequestBytes: number;
+  memoryP95Bytes: number;
+}
+
+export const fetchNodePods = async (name: string, window: string): Promise<PodMetrics[]> => {
+  return request<PodMetrics[]>(`/cost/nodes/${name}/pods?window=${window}`);
+};
+
 export const fetchResources = async (): Promise<ResourcesSummary> => {
   const resp = await request<ResourcesApiResponse>("/cost/resources");
   return {
diff --git a/web/src/pages/namespaces/NamespacesPage.test.tsx b/web/src/pages/namespaces/NamespacesPage.test.tsx
index 2f115ed..d8783e4 100644
--- a/web/src/pages/namespaces/NamespacesPage.test.tsx
+++ b/web/src/pages/namespaces/NamespacesPage.test.tsx
@@ -11,6 +11,7 @@ vi.mock("../../hooks/useApiData", () => ({
 }));
 
 // Mock ResizeObserver
+// @ts-ignore
 global.ResizeObserver = class ResizeObserver {
   observe() { }
   unobserve() { }
diff --git a/web/src/pages/nodes/NodesPage.tsx b/web/src/pages/nodes/NodesPage.tsx
index e78218d..0e3c9f5 100644
--- a/web/src/pages/nodes/NodesPage.tsx
+++ b/web/src/pages/nodes/NodesPage.tsx
@@ -1,365 +1,362 @@
-import { useMemo, useState, type ChangeEvent } from "react";
+import { useMemo, useState, useCallback, type ChangeEvent } from "react";
 import { fetchNodes, type NodeCost } from "../../lib/api";
-import { formatCurrency, formatPercentage, relativeTimeFromIso, toMonthlyCost } from "../../lib/utils";
+import { formatCurrency, formatPercentage, relativeTimeFromIso, toMonthlyCost, milliToCores } from "../../lib/utils";
 import { useApiData } from "../../hooks/useApiData";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
-import { Progress } from "@/components/ui/progress";
 import { Badge } from "@/components/ui/badge";
 import { Input } from "@/components/ui/input";
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
 import { Skeleton } from "@/components/ui/skeleton";
 import NodeDetailSheet from "@/components/nodes/NodeDetailSheet";
+import { MetricCard } from "@/components/common/MetricCard";
+import { EfficiencyBar } from "@/components/nodes/EfficiencyBar";
+import { AlertTriangleIcon, CheckCircle2Icon, SearchIcon, ArrowDownIcon } from "lucide-react";
+import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 
-const statusStyles: Record<NodeCost["status"], string> = {
-  Ready: "border-emerald-500/40 bg-emerald-500/10 text-emerald-200",
-  NotReady: "border-destructive/40 bg-destructive/10 text-destructive",
-  Unknown: "border-muted bg-muted/40 text-muted-foreground"
-};
-
-type SortKey = "cost" | "cpu" | "memory";
+type SortKey = "cost" | "waste" | "efficiency";
 
 const NodesPage = () => {
-  const { data, loading, error, refresh } = useApiData(fetchNodes);
+  const [timeWindow, setTimeWindow] = useState("24h");
+
+  // Fetch with window
+  const fetchNodesWithWindow = useCallback(() => fetchNodes(timeWindow), [timeWindow]);
+  const { data, loading, error, refresh } = useApiData(fetchNodesWithWindow);
+
   const nodes = data ?? [];
   const [search, setSearch] = useState("");
-  const [sortKey, setSortKey] = useState<SortKey>("cost");
+  const [sortKey, setSortKey] = useState<SortKey>("cost"); // Default to cost for financial view
   const [sortDirection, setSortDirection] = useState<"asc" | "desc">("desc");
   const [selectedNode, setSelectedNode] = useState<(NodeCost & { monthlyCost: number }) | null>(null);
 
+  // Fallback Cost Logic
+  const getEstimatedCost = (instanceType: string | undefined): number => {
+    if (!instanceType) return 73;
+    if (instanceType.includes("nano")) return 4;
+    if (instanceType.includes("micro")) return 8;
+    if (instanceType.includes("small")) return 16;
+    if (instanceType.includes("medium")) return 32;
+    if (instanceType.includes("large") && !instanceType.includes("xlarge")) return 64;
+    if (instanceType.includes("xlarge")) return 128;
+    if (instanceType.includes("2xlarge")) return 256;
+    return 73;
+  };
+
   const derivedNodes = useMemo(() => {
-    return nodes.map((node) => ({
-      ...node,
-      cpuUsagePercent: node.cpuUsagePercent ?? 0,
-      memoryUsagePercent: node.memoryUsagePercent ?? 0,
-      hourlyCost: node.hourlyCost ?? 0,
-      monthlyCost: toMonthlyCost(node.hourlyCost ?? 0)
-    }));
+    return nodes.map((node) => {
+      let hourlyCost = node.hourlyCost ?? 0;
+      let isEstimate = false;
+
+      if (hourlyCost === 0) {
+        hourlyCost = getEstimatedCost(node.instanceType) / 730;
+        isEstimate = true;
+      }
+
+      // Use backend provided WindowCost if activeHours logic applied, otherwise calculate projection
+      const windowCost = node.windowCost || (hourlyCost * 24); // fallback
+      const monthlyCost = hourlyCost * 730; // Still useful for reference
+
+      const cpuAllocatable = node.cpuAllocatableMilli ?? 0;
+      const cpuRequestPercent = cpuAllocatable > 0 ? ((node.cpuRequestedMilli ?? 0) / cpuAllocatable) * 100 : 0;
+      const cpuUsage = node.cpuUsagePercent ?? 0;
+
+      // Calculate Memory Stats
+      const memAllocatable = node.memoryAllocatableBytes ?? 0;
+      const memRequestPercent = memAllocatable > 0 ? ((node.memoryRequestedBytes ?? 0) / memAllocatable) * 100 : 0;
+      const memUsage = node.memoryUsagePercent ?? 0;
+
+      // FinOps Waste Calculation
+      const wastePercent = Math.max(0, cpuRequestPercent - cpuUsage);
+      // Waste Amount based on Window Cost
+      const wasteAmount = windowCost * (wastePercent / 100);
+
+      const isEfficient = wastePercent < 15;
+      const isOverProvisioned = wastePercent > 30;
+
+      return {
+        ...node,
+        cpuUsagePercent: cpuUsage,
+        cpuRequestPercent,
+        memoryUsagePercent: memUsage,
+        memRequestPercent,
+        monthlyCost,
+        windowCost,
+        isEstimate,
+        wastePercent,
+        wasteAmount,
+        isEfficient,
+        isOverProvisioned,
+        shortName: node.nodeName // no truncation
+      };
+    });
   }, [nodes]);
 
   const summary = useMemo(() => {
-    const totalMonthly = derivedNodes.reduce((sum, node) => sum + node.monthlyCost, 0);
-    const avgCpu = derivedNodes.length
-      ? derivedNodes.reduce((sum, node) => sum + node.cpuUsagePercent, 0) / derivedNodes.length
-      : 0;
-    const avgMem = derivedNodes.length
-      ? derivedNodes.reduce((sum, node) => sum + node.memoryUsagePercent, 0) / derivedNodes.length
-      : 0;
-    const issueCount = derivedNodes.filter((node) => node.status !== "Ready" || node.isUnderPressure).length;
-    return { totalMonthly, avgCpu, avgMem, ready: derivedNodes.length - issueCount, issues: issueCount };
-  }, [derivedNodes]);
+    const totalWindowCost = derivedNodes.reduce((sum, n) => sum + n.windowCost, 0);
+    const totalWaste = derivedNodes.reduce((sum, n) => sum + n.wasteAmount, 0);
+    const potentialSavings = totalWaste * 0.6;
 
-  const filteredNodes = useMemo(() => {
-    const term = search.trim().toLowerCase();
-    if (!term) return derivedNodes;
-    return derivedNodes.filter((node) => node.nodeName.toLowerCase().includes(term));
-  }, [derivedNodes, search]);
+    return { totalWindowCost, totalWaste, potentialSavings };
+  }, [derivedNodes]);
 
   const sortedNodes = useMemo(() => {
-    const rows = [...filteredNodes];
-    const valueFor = (node: (typeof derivedNodes)[number]) => {
-      if (sortKey === "cpu") return node.cpuUsagePercent;
-      if (sortKey === "memory") return node.memoryUsagePercent;
-      return node.monthlyCost;
-    };
+    const rows = [...derivedNodes];
     rows.sort((a, b) => {
-      const diff = valueFor(a) - valueFor(b);
-      return sortDirection === "asc" ? diff : -diff;
+      const valA = sortKey === "waste" ? a.wasteAmount : (sortKey === "cost" ? a.windowCost : a.wastePercent);
+      const valB = sortKey === "waste" ? b.wasteAmount : (sortKey === "cost" ? b.windowCost : b.wastePercent);
+      return sortDirection === "asc" ? valA - valB : valB - valA;
     });
     return rows;
-  }, [filteredNodes, sortKey, sortDirection]);
+  }, [derivedNodes, sortKey, sortDirection]);
 
   const handleSort = (key: SortKey) => {
-    if (key === sortKey) {
-      setSortDirection((dir) => (dir === "desc" ? "asc" : "desc"));
-    } else {
-      setSortKey(key);
-      setSortDirection("desc");
-    }
+    if (key === sortKey) setSortDirection(d => d === "desc" ? "asc" : "desc");
+    else { setSortKey(key); setSortDirection("desc"); }
   };
 
-  const optimizationCandidates = useMemo(() => {
-    if (!derivedNodes.length) return [];
-    const sortedCosts = [...derivedNodes].sort((a, b) => b.monthlyCost - a.monthlyCost);
-    const index = Math.max(0, Math.floor(sortedCosts.length * 0.3) - 1);
-    const costThreshold = sortedCosts[index]?.monthlyCost ?? 0;
-    return derivedNodes
-      .filter(
-        (node) =>
-          node.monthlyCost >= costThreshold && node.cpuUsagePercent < 35 && node.memoryUsagePercent < 35
-      )
-      .sort((a, b) => b.monthlyCost - a.monthlyCost)
-      .slice(0, 5);
-  }, [derivedNodes]);
-
-  const alerts = useMemo(() => {
-    return derivedNodes
-      .map((node) => {
-        const reasons: string[] = [];
-        if (node.status !== "Ready") reasons.push(node.status);
-        if (node.cpuUsagePercent >= 85) reasons.push(`CPU ${node.cpuUsagePercent.toFixed(0)}%`);
-        if (node.memoryUsagePercent >= 85) reasons.push(`Memory ${node.memoryUsagePercent.toFixed(0)}%`);
-        if (node.isUnderPressure) reasons.push("Under pressure");
-        return { node, reasons };
-      })
-      .filter((item) => item.reasons.length > 0)
-      .slice(0, 5);
-  }, [derivedNodes]);
-
-  const lastUpdatedLabel = data?.[0]?.lastUpdated ? relativeTimeFromIso(data[0].lastUpdated) : "moments ago";
-
-  const renderSortLabel = (key: SortKey, label: string) => (
-    <button
-      className="flex items-center gap-1 text-left text-xs font-medium uppercase tracking-wide text-muted-foreground"
-      onClick={() => handleSort(key)}
-    >
-      {label}
-      {sortKey === key && <span>{sortDirection === "desc" ? "↓" : "↑"}</span>}
-    </button>
-  );
-
-  if (loading && !data) {
-    return <Skeleton className="h-[70vh] w-full" />;
-  }
+  const getWindowLabel = (w: string) => {
+    switch (w) {
+      case "24h": return "Last 24 Hours";
+      case "7d": return "Last 7 Days";
+      case "30d": return "Last 30 Days";
+      default: return w;
+    }
+  };
 
-  if (error) {
-    return (
-      <Card className="border-destructive/30 bg-destructive/5">
-        <CardContent className="py-10 text-center text-sm text-destructive">{error}</CardContent>
-      </Card>
-    );
-  }
-
-  if (!derivedNodes.length) {
-    return (
-      <Card>
-        <CardHeader>
-          <CardTitle>No nodes</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-3 text-sm text-muted-foreground">
-          <p>We couldn’t find any nodes. Once data arrives it will show up here.</p>
-          <Button variant="outline" onClick={refresh} className="w-fit">
-            Refresh
-          </Button>
-        </CardContent>
-      </Card>
-    );
-  }
+  if (loading && !data) return <Skeleton className="h-[80vh] w-full rounded-xl" />;
+  if (error) return <div className="text-red-500 p-10 text-center">Failed to load data: {error}</div>;
 
   return (
-    <div className="space-y-6">
-      <header className="flex flex-wrap items-center justify-between gap-3">
+    <div className="space-y-8 p-1">
+      {/* Header Section */}
+      <div className="flex justify-between items-end border-b border-border/40 pb-6">
         <div>
-          <h1 className="text-2xl font-semibold">Nodes</h1>
-          <p className="text-sm text-muted-foreground">See how much each node costs and how full it is.</p>
+          <h1 className="text-3xl font-bold tracking-tight">Cluster Financials</h1>
+          <p className="text-muted-foreground mt-1">Real-time analysis based on actual uptime.</p>
         </div>
-        <div className="text-sm text-muted-foreground">Last updated {lastUpdatedLabel}</div>
-      </header>
+        <div className="flex gap-3 items-center">
+          <Select value={timeWindow} onValueChange={setTimeWindow}>
+            <SelectTrigger className="w-[180px]">
+              <SelectValue placeholder="Select Window" />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="24h">Last 24 Hours</SelectItem>
+              <SelectItem value="7d">Last 7 Days</SelectItem>
+              <SelectItem value="30d">Last 30 Days</SelectItem>
+            </SelectContent>
+          </Select>
+          <Button variant="outline" size="sm" onClick={refresh}>Refresh</Button>
+          <Button size="sm">Download Report</Button>
+        </div>
+      </div>
 
-      <section className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
-        <Card>
+      {/* The "Truth" Cards */}
+      <div className="grid gap-6 md:grid-cols-3">
+        <Card className="bg-card/50 backdrop-blur-sm shadow-sm md:col-span-1">
           <CardHeader className="pb-2">
-            <CardTitle className="text-xs uppercase tracking-wide text-muted-foreground">Total node cost</CardTitle>
+            <CardTitle className="text-sm font-medium text-muted-foreground uppercase tracking-wider">
+              Spend ({timeWindow})
+            </CardTitle>
           </CardHeader>
           <CardContent>
-            <p className="text-2xl font-semibold">{formatCurrency(summary.totalMonthly)}</p>
-            <p className="text-xs text-muted-foreground">Monthly (hourly x 30 days)</p>
-          </CardContent>
-        </Card>
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-xs uppercase tracking-wide text-muted-foreground">Avg CPU usage</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <p className="text-2xl font-semibold">{formatPercentage(summary.avgCpu, { fractionDigits: 0 })}</p>
-            <Progress value={summary.avgCpu} className="mt-2" />
+            <div className="text-4xl font-bold tracking-tighter text-foreground">
+              {formatCurrency(summary.totalWindowCost)}
+            </div>
+            <p className="text-xs text-muted-foreground mt-1">
+              Actual cost based on {getWindowLabel(timeWindow)} uptime
+            </p>
           </CardContent>
         </Card>
-        <Card>
+
+        <Card className="bg-card/50 backdrop-blur-sm shadow-sm md:col-span-1 border-destructive/20 relative overflow-hidden">
+          <div className="absolute top-0 right-0 p-2">
+            {summary.totalWaste > 0 && (
+              <Badge variant="destructive" className="uppercase text-[10px] tracking-widest font-bold">Action Required</Badge>
+            )}
+          </div>
           <CardHeader className="pb-2">
-            <CardTitle className="text-xs uppercase tracking-wide text-muted-foreground">Avg memory usage</CardTitle>
+            <CardTitle className="text-sm font-medium text-muted-foreground uppercase tracking-wider flex items-center gap-2">
+              Waste ({timeWindow}) <AlertTriangleIcon className="w-4 h-4 text-destructive" />
+            </CardTitle>
           </CardHeader>
           <CardContent>
-            <p className="text-2xl font-semibold">{formatPercentage(summary.avgMem, { fractionDigits: 0 })}</p>
-            <Progress value={summary.avgMem} className="mt-2" />
+            <div className={`text-5xl font-extrabold tracking-tighter ${summary.totalWaste > 0 ? "text-destructive" : "text-emerald-500"}`}>
+              {formatCurrency(summary.totalWaste)}
+            </div>
+            <p className="text-xs text-muted-foreground mt-2 font-mono">
+              Money burned on unused capacity
+            </p>
           </CardContent>
         </Card>
-        <Card>
+
+        <Card className="bg-card/50 backdrop-blur-sm shadow-sm md:col-span-1 border-emerald-500/20">
           <CardHeader className="pb-2">
-            <CardTitle className="text-xs uppercase tracking-wide text-muted-foreground">Node health</CardTitle>
+            <CardTitle className="text-sm font-medium text-muted-foreground uppercase tracking-wider">Actionable Savings</CardTitle>
           </CardHeader>
           <CardContent>
-            <p className="text-2xl font-semibold">
-              {summary.ready} Ready · {summary.issues} With issues
-            </p>
-            <p className="text-xs text-muted-foreground">Issues = NotReady or under pressure</p>
-          </CardContent>
-        </Card>
-      </section>
-
-      <section className="grid gap-6 lg:grid-cols-[minmax(0,2fr)_minmax(0,1fr)]">
-        <Card>
-          <CardHeader className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
-            <div>
-              <CardTitle>Nodes</CardTitle>
-              <p className="text-sm text-muted-foreground">Sorted by monthly cost</p>
-            </div>
-            <div className="w-full sm:max-w-xs">
-              <Input
-                placeholder="Search nodes"
-                value={search}
-                onChange={(event: ChangeEvent<HTMLInputElement>) => setSearch(event.target.value)}
-                className="h-9 w-full"
-              />
-            </div>
-          </CardHeader>
-          <CardContent className="space-y-4">
-            <div className="hidden lg:block">
-              <div className="overflow-hidden rounded-md border">
-                <div className="overflow-x-auto">
-                  <Table>
-                    <TableHeader>
-                      <TableRow>
-                        <TableHead className="min-w-[200px]">Node</TableHead>
-                        <TableHead>{renderSortLabel("cost", "Monthly cost")}</TableHead>
-                        <TableHead>{renderSortLabel("cpu", "CPU usage")}</TableHead>
-                        <TableHead>{renderSortLabel("memory", "Memory usage")}</TableHead>
-                        <TableHead>Status</TableHead>
-                      </TableRow>
-                    </TableHeader>
-                    <TableBody>
-                      {sortedNodes.map((node) => (
-                        <TableRow key={node.nodeName} className="cursor-pointer" onClick={() => setSelectedNode(node)}>
-                          <TableCell>
-                            <div className="flex flex-col gap-1">
-                              <span className="font-medium">{node.nodeName}</span>
-                              {node.instanceType && (
-                                <span className="w-fit rounded bg-muted px-2 py-0.5 text-[11px] text-muted-foreground">
-                                  {node.instanceType}
-                                </span>
-                              )}
-                            </div>
-                          </TableCell>
-                          <TableCell className="whitespace-nowrap font-medium">
-                            {formatCurrency(node.monthlyCost)}
-                          </TableCell>
-                          <TableCell className="w-48">
-                            <div className="flex items-center gap-2 text-sm">
-                              <Progress value={node.cpuUsagePercent} className="h-2 flex-1" />
-                              <span className="text-xs text-muted-foreground">{node.cpuUsagePercent.toFixed(0)}%</span>
-                            </div>
-                          </TableCell>
-                          <TableCell className="w-48">
-                            <div className="flex items-center gap-2 text-sm">
-                              <Progress value={node.memoryUsagePercent} className="h-2 flex-1" />
-                              <span className="text-xs text-muted-foreground">{node.memoryUsagePercent.toFixed(0)}%</span>
-                            </div>
-                          </TableCell>
-                          <TableCell>
-                            <Badge className={statusStyles[node.status]} variant="outline">
-                              {node.status}
-                            </Badge>
-                          </TableCell>
-                        </TableRow>
-                      ))}
-                    </TableBody>
-                  </Table>
-                </div>
-              </div>
-            </div>
-            <div className="space-y-3 lg:hidden">
-              {sortedNodes.map((node) => (
-                <button
-                  key={node.nodeName}
-                  onClick={() => setSelectedNode(node)}
-                  className="w-full rounded-md border border-border/60 p-3 text-left"
-                >
-                  <div className="flex items-center justify-between">
-                    <div>
-                      <p className="font-semibold">{node.nodeName}</p>
-                      {node.instanceType && (
-                        <p className="text-xs text-muted-foreground">{node.instanceType}</p>
-                      )}
-                    </div>
-                    <span className="text-sm font-semibold">{formatCurrency(node.monthlyCost)}</span>
-                  </div>
-                  <div className="mt-2 grid grid-cols-2 gap-3 text-xs text-muted-foreground">
-                    <div>
-                      <p>CPU {node.cpuUsagePercent.toFixed(0)}%</p>
-                      <Progress value={node.cpuUsagePercent} className="mt-1 h-1.5" />
-                    </div>
-                    <div>
-                      <p>Mem {node.memoryUsagePercent.toFixed(0)}%</p>
-                      <Progress value={node.memoryUsagePercent} className="mt-1 h-1.5" />
-                    </div>
-                  </div>
-                  <div className="mt-2 flex items-center gap-2 text-xs">
-                    <Badge className={statusStyles[node.status]} variant="outline">
-                      {node.status}
-                    </Badge>
-                    {node.isUnderPressure && <Badge variant="destructive">Pressure</Badge>}
-                  </div>
-                </button>
-              ))}
+            <div className="text-4xl font-bold tracking-tighter text-emerald-500">
+              {formatCurrency(summary.potentialSavings)}
             </div>
+            <p className="text-xs text-muted-foreground mt-1">
+              Conservative achievable reduction
+            </p>
           </CardContent>
         </Card>
+      </div>
+
+      {/* FinOps Table - High Density */}
+      <Card className="border-0 shadow-none bg-transparent">
+        <div className="flex flex-col sm:flex-row justify-between items-center mb-4 gap-4">
+          <div className="flex items-center gap-2">
+            <Badge variant="outline" className="h-6 px-2 text-xs">
+              {sortedNodes.length} Nodes (Active in {timeWindow})
+            </Badge>
+          </div>
+          <div className="relative w-full sm:max-w-xs">
+            <SearchIcon className="absolute left-2 top-2.5 h-4 w-4 text-muted-foreground" />
+            <Input
+              placeholder="Filter by node or instance..."
+              className="pl-8 h-9 bg-background/60"
+              value={search}
+              onChange={(e) => setSearch(e.target.value)}
+            />
+          </div>
+        </div>
 
-        <div className="space-y-6">
-          <Card>
-            <CardHeader>
-              <CardTitle>Optimization ideas</CardTitle>
-            </CardHeader>
-            <CardContent className="space-y-3">
-              {optimizationCandidates.length === 0 ? (
-                <p className="text-sm text-muted-foreground">Looks good, no obvious wasted nodes right now.</p>
-              ) : (
-                optimizationCandidates.map((node) => (
-                  <div key={node.nodeName} className="rounded border border-border/60 p-3">
-                    <div className="flex items-center justify-between text-sm">
-                      <span className="font-medium">{node.nodeName}</span>
-                      <span>{formatCurrency(node.monthlyCost)}</span>
+        <div className="rounded-lg border bg-card/60 overflow-hidden">
+          <Table>
+            <TableHeader className="bg-muted/30">
+              <TableRow className="hover:bg-transparent border-b border-border/50">
+                <TableHead className="w-[200px] font-semibold text-foreground">Node Identity</TableHead>
+                <TableHead className="w-[150px] font-semibold text-foreground cursor-pointer" onClick={() => handleSort("cost")}>
+                  Cost ({timeWindow}) <span className="text-[10px] ml-1 font-normal opacity-50">▼</span>
+                </TableHead>
+                <TableHead className="w-[250px] font-semibold text-foreground">
+                  CPU Efficiency
+                  <span className="ml-2 text-[10px] font-normal text-muted-foreground whitespace-nowrap opacity-80">
+                    (<span className="text-cyan-500">●</span> Usage / <span className="text-primary/50">●</span> Reserved)
+                  </span>
+                </TableHead>
+                <TableHead className="w-[250px] font-semibold text-foreground">
+                  Memory Efficiency
+                  <span className="ml-2 text-[10px] font-normal text-muted-foreground whitespace-nowrap opacity-80">
+                    (<span className="text-cyan-500">●</span> Usage / <span className="text-primary/50">●</span> Reserved)
+                  </span>
+                </TableHead>
+                <TableHead className="text-right pr-6 font-semibold text-foreground cursor-pointer" onClick={() => handleSort("waste")}>Action</TableHead>
+              </TableRow>
+            </TableHeader>
+            <TableBody>
+              {sortedNodes.filter(n => n.nodeName.includes(search)).map((node) => (
+                <TableRow key={node.nodeName} className="border-b border-border/40 hover:bg-muted/30 transition-colors">
+
+                  {/* Column 1: Identity */}
+                  <TableCell className="py-4 align-top">
+                    <div className="flex flex-col gap-0.5 max-w-[220px]">
+                      <span className="font-bold text-sm text-foreground">{node.instanceType || "Unknown"}</span>
+                      <TooltipProvider>
+                        <Tooltip>
+                          <TooltipTrigger asChild>
+                            <span className="text-xs text-muted-foreground font-mono break-all cursor-help opacity-70 hover:opacity-100 leading-tight">
+                              {node.nodeName}
+                            </span>
+                          </TooltipTrigger>
+                          <TooltipContent>
+                            <p className="font-mono text-xs">{node.nodeName}</p>
+                          </TooltipContent>
+                        </Tooltip>
+                      </TooltipProvider>
                     </div>
-                    <p className="text-xs text-muted-foreground">
-                      {node.cpuUsagePercent.toFixed(0)}% CPU · {node.memoryUsagePercent.toFixed(0)}% Mem
-                    </p>
-                  </div>
-                ))
-              )}
-            </CardContent>
-          </Card>
-
-          <Card>
-            <CardHeader>
-              <CardTitle>Alerts</CardTitle>
-            </CardHeader>
-            <CardContent className="space-y-3">
-              {alerts.length === 0 ? (
-                <p className="text-sm text-muted-foreground">All nodes healthy.</p>
-              ) : (
-                alerts.map(({ node, reasons }) => (
-                  <div key={node.nodeName} className="rounded border border-border/60 p-3">
-                    <div className="flex items-center justify-between text-sm">
-                      <span className="font-medium">{node.nodeName}</span>
-                      <Badge variant="destructive">Check</Badge>
+                  </TableCell>
+
+                  {/* Column 2: Cost */}
+                  <TableCell className="py-4 align-top">
+                    <div className="flex flex-col">
+                      <div className="flex items-baseline gap-1">
+                        <span className={`${node.isEstimate ? "text-muted-foreground font-normal" : "font-bold text-foreground"}`}>
+                          {formatCurrency(node.windowCost)}
+                        </span>
+                        {node.isEstimate && (
+                          <TooltipProvider>
+                            <Tooltip>
+                              <TooltipTrigger asChild><span className="text-[10px] text-amber-500 cursor-help">*</span></TooltipTrigger>
+                              <TooltipContent>Estimated Cost</TooltipContent>
+                            </Tooltip>
+                          </TooltipProvider>
+                        )}
+                      </div>
+                      <div className="flex flex-col gap-0.5 mt-0.5">
+                        <span className="text-[10px] text-muted-foreground font-mono">
+                          ${Number(node.hourlyCost.toFixed(4))}/hr
+                        </span>
+                        {node.activeHours > 0 && (
+                          <span className="text-[10px] text-emerald-600/70 font-mono">
+                            {node.activeHours.toFixed(1)}h active ({((node.activeRatio || 0) * 100).toFixed(0)}%)
+                          </span>
+                        )}
+                      </div>
                     </div>
-                    <p className="text-xs text-muted-foreground">{reasons.join(" · ")}</p>
-                  </div>
-                ))
-              )}
-            </CardContent>
-          </Card>
+                  </TableCell>
+
+                  {/* Column 3: CPU Efficiency (Stacked) */}
+                  <TableCell className="py-3 align-top">
+                    <EfficiencyBar
+                      usagePercent={node.cpuUsagePercent}
+                      requestPercent={node.cpuRequestPercent}
+                      costPerMonth={node.monthlyCost}
+                      usageAbsolute={node.cpuAllocatableMilli ? (node.cpuUsagePercent / 100) * (node.cpuAllocatableMilli / 1000) : 0}
+                      totalAbsolute={node.cpuAllocatableMilli ? node.cpuAllocatableMilli / 1000 : 0}
+                      unit="vCPUs"
+                    />
+                  </TableCell>
+
+                  {/* Column 4: RAM Efficiency (Stacked) */}
+                  <TableCell className="py-3 align-top">
+                    <EfficiencyBar
+                      usagePercent={node.memoryUsagePercent}
+                      requestPercent={node.memRequestPercent}
+                      costPerMonth={node.monthlyCost}
+                      usageAbsolute={node.memoryAllocatableBytes ? (node.memoryUsagePercent / 100) * (node.memoryAllocatableBytes / (1024 * 1024 * 1024)) : 0}
+                      totalAbsolute={node.memoryAllocatableBytes ? node.memoryAllocatableBytes / (1024 * 1024 * 1024) : 0}
+                      unit="GiB"
+                    />
+                  </TableCell>
+
+                  {/* Column 5: Action */}
+                  <TableCell className="py-4 align-top text-right pr-6">
+                    {node.isEfficient ? (
+                      <Badge variant="secondary" className="bg-emerald-500/10 text-emerald-600 border-0">
+                        <CheckCircle2Icon className="w-3 h-3 mr-1" /> Optimized
+                      </Badge>
+                    ) : (
+                      <div className="flex flex-col items-end gap-1">
+                        <Button
+                          variant="outline"
+                          size="sm"
+                          className={`h-7 text-xs ${node.wastePercent > 50 ? "border-destructive/50 text-destructive hover:bg-destructive/10" : "border-amber-500/50 text-amber-600 hover:bg-amber-500/10"}`}
+                          onClick={() => setSelectedNode(node)}
+                        >
+                          <ArrowDownIcon className="w-3 h-3 mr-1" />
+                          {node.wastePercent > 50 ? "Fix Waste" : "Rightsize"}
+                        </Button>
+                        <span className="text-[10px] text-muted-foreground font-mono">
+                          Save ~{formatCurrency(node.wasteAmount)}
+                        </span>
+                      </div>
+                    )}
+                  </TableCell>
+                </TableRow>
+              ))}
+            </TableBody>
+          </Table>
         </div>
-      </section>
+      </Card>
 
       <NodeDetailSheet
         node={selectedNode}
         open={!!selectedNode}
-        onOpenChange={(open) => {
-          if (!open) {
-            setSelectedNode(null);
-          }
-        }}
+        onOpenChange={(open) => { if (!open) setSelectedNode(null); }}
       />
     </div>
   );
diff --git a/web/src/pages/resources/ResourcesPage.tsx b/web/src/pages/resources/ResourcesPage.tsx
index 66d173a..b1ae086 100644
--- a/web/src/pages/resources/ResourcesPage.tsx
+++ b/web/src/pages/resources/ResourcesPage.tsx
@@ -13,6 +13,7 @@ import {
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Progress } from "@/components/ui/progress";
 import { Skeleton } from "@/components/ui/skeleton";
+import { Button } from "@/components/ui/button";
 import { Sheet, SheetContent, SheetDescription, SheetHeader, SheetTitle } from "@/components/ui/sheet";
 import { Badge } from "@/components/ui/badge";
 import { ResponsiveContainer, Bar, BarChart, Legend, Tooltip, XAxis, YAxis } from "recharts";
diff --git a/web/vite.config.ts b/web/vite.config.ts
index 7178a0a..a1afe31 100644
--- a/web/vite.config.ts
+++ b/web/vite.config.ts
@@ -1,27 +1,43 @@
-import { defineConfig } from "vite";
+import { defineConfig, loadEnv } from "vite";
 import react from "@vitejs/plugin-react";
 import path from "path"
 
-export default defineConfig({
-  plugins: [react()],
-  resolve: {
-    alias: {
-      "@": path.resolve(__dirname, "./src"),
+export default defineConfig(({ mode }) => {
+  // Load env file based on `mode` in the current working directory.
+  // Set the third parameter to '' to load all env regardless of the `VITE_` prefix.
+  const env = loadEnv(mode, process.cwd(), '');
+
+  // Priority: Shell Env (process.env) > .env File (env) > Default
+  const apiTarget = process.env.VITE_API_TARGET || env.VITE_API_TARGET || "http://localhost:9090";
+
+  console.log(`[Vite] Proxying /api to: ${apiTarget}`);
+
+  return {
+    plugins: [react()],
+    resolve: {
+      alias: {
+        "@": path.resolve(__dirname, "./src"),
+      },
+    },
+    server: {
+      port: 5173,
+      proxy: {
+        "/api": {
+          target: apiTarget,
+          changeOrigin: true,
+          // If you want to strip /api prefix from the request when proxying:
+          // rewrite: (path) => path.replace(/^\/api/, ''),
+        }
+      }
+    },
+    build: {
+      outDir: "dist",
+      emptyOutDir: true
     },
-  },
-  server: {
-    port: 5173,
-    proxy: {
-      "/api": "http://localhost:9090"
+    test: {
+      globals: true,
+      environment: "jsdom",
+      setupFiles: "./src/test/setup.ts"
     }
-  },
-  build: {
-    outDir: "dist",
-    emptyOutDir: true
-  },
-  test: {
-    globals: true,
-    environment: "jsdom",
-    setupFiles: "./src/test/setup.ts"
-  }
+  };
 });