diff --git a/docs/SUMMARY.md b/docs/SUMMARY.md
index 50fea300675..7d85aba1ad0 100644
--- a/docs/SUMMARY.md
+++ b/docs/SUMMARY.md
@@ -158,6 +158,7 @@
   * [Registry server](reference/feature-servers/registry-server.md)
 * [\[Beta\] Web UI](reference/alpha-web-ui.md)
 * [\[Beta\] On demand feature view](reference/beta-on-demand-feature-view.md)
+* [\[Alpha\] Static Artifacts Loading](reference/alpha-static-artifacts.md)
 * [\[Alpha\] Vector Database](reference/alpha-vector-database.md)
 * [\[Alpha\] Data quality monitoring](reference/dqm.md)
 * [\[Alpha\] Streaming feature computation with Denormalized](reference/denormalized.md)
diff --git a/docs/reference/alpha-static-artifacts.md b/docs/reference/alpha-static-artifacts.md
new file mode 100644
index 00000000000..627898f847f
--- /dev/null
+++ b/docs/reference/alpha-static-artifacts.md
@@ -0,0 +1,314 @@
+# [Alpha] Static Artifacts Loading
+
+**Warning**: This is an experimental feature. To our knowledge, this is stable, but there are still rough edges in the experience. Contributions are welcome!
+
+## Overview
+
+Static Artifacts Loading allows you to load models, lookup tables, and other static resources once during feature server startup instead of loading them on each request. These artifacts are cached in memory and accessible to on-demand feature views for real-time inference.
+
+This feature optimizes the performance of on-demand feature views that require external resources by eliminating the overhead of repeatedly loading the same artifacts during request processing.
+
+### Why Use Static Artifacts Loading?
+
+Static artifacts loading enables data scientists and ML engineers to:
+
+1. **Improve performance**: Eliminate model loading overhead from each feature request
+2. **Enable complex transformations**: Use pre-trained models in on-demand feature views without performance penalties
+3. **Share resources**: Multiple feature views can access the same loaded artifacts
+4. **Simplify deployment**: Package models and lookup tables with your feature repository
+
+Common use cases include:
+- Sentiment analysis using pre-trained transformers models
+- Text classification with small neural networks
+- Lookup-based transformations using static dictionaries
+- Embedding generation with pre-computed vectors
+
+## How It Works
+
+1. **Feature Repository Setup**: Create a `static_artifacts.py` file in your feature repository root
+2. **Server Startup**: When `feast serve` starts, it automatically looks for and loads the artifacts
+3. **Memory Storage**: Artifacts are stored in the FastAPI application state and accessible via global references
+4. **Request Processing**: On-demand feature views access pre-loaded artifacts for fast transformations
+
+## Example 1: Basic Model Loading
+
+Create a `static_artifacts.py` file in your feature repository:
+
+```python
+# static_artifacts.py
+from fastapi import FastAPI
+from transformers import pipeline
+
+def load_sentiment_model():
+    """Load sentiment analysis model."""
+    return pipeline(
+        "sentiment-analysis",
+        model="cardiffnlp/twitter-roberta-base-sentiment-latest",
+        device="cpu"
+    )
+
+def load_artifacts(app: FastAPI):
+    """Load static artifacts into app.state."""
+    app.state.sentiment_model = load_sentiment_model()
+
+    # Update global references for access from feature views
+    import example_repo
+    example_repo._sentiment_model = app.state.sentiment_model
+```
+
+Use the pre-loaded model in your on-demand feature view:
+
+```python
+# example_repo.py
+import pandas as pd
+from feast.on_demand_feature_view import on_demand_feature_view
+from feast import Field
+from feast.types import String, Float32
+
+# Global reference for static artifacts
+_sentiment_model = None
+
+@on_demand_feature_view(
+    sources=[text_input_request],
+    schema=[
+        Field(name="predicted_sentiment", dtype=String),
+        Field(name="sentiment_confidence", dtype=Float32),
+    ],
+)
+def sentiment_prediction(inputs: pd.DataFrame) -> pd.DataFrame:
+    """Sentiment prediction using pre-loaded model."""
+    global _sentiment_model
+
+    results = []
+    for text in inputs["input_text"]:
+        predictions = _sentiment_model(text)
+        best_pred = max(predictions, key=lambda x: x["score"])
+
+        results.append({
+            "predicted_sentiment": best_pred["label"],
+            "sentiment_confidence": best_pred["score"],
+        })
+
+    return pd.DataFrame(results)
+```
+
+## Example 2: Multiple Artifacts with Lookup Tables
+
+Load multiple types of artifacts:
+
+```python
+# static_artifacts.py
+from fastapi import FastAPI
+from transformers import pipeline
+import json
+from pathlib import Path
+
+def load_sentiment_model():
+    """Load sentiment analysis model."""
+    return pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
+
+def load_lookup_tables():
+    """Load static lookup tables."""
+    return {
+        "sentiment_labels": {"NEGATIVE": "negative", "POSITIVE": "positive"},
+        "domain_categories": {"twitter.com": "social", "news.com": "news", "github.com": "tech"},
+        "priority_users": {"user_123", "user_456", "user_789"}
+    }
+
+def load_config():
+    """Load application configuration."""
+    return {
+        "model_threshold": 0.7,
+        "max_text_length": 512,
+        "default_sentiment": "neutral"
+    }
+
+def load_artifacts(app: FastAPI):
+    """Load all static artifacts."""
+    app.state.sentiment_model = load_sentiment_model()
+    app.state.lookup_tables = load_lookup_tables()
+    app.state.config = load_config()
+
+    # Update global references
+    import example_repo
+    example_repo._sentiment_model = app.state.sentiment_model
+    example_repo._lookup_tables = app.state.lookup_tables
+    example_repo._config = app.state.config
+```
+
+Use multiple artifacts in feature transformations:
+
+```python
+# example_repo.py
+import pandas as pd
+from feast.on_demand_feature_view import on_demand_feature_view
+
+# Global references for static artifacts
+_sentiment_model = None
+_lookup_tables: dict = {}
+_config: dict = {}
+
+@on_demand_feature_view(
+    sources=[text_input_request, user_input_request],
+    schema=[
+        Field(name="predicted_sentiment", dtype=String),
+        Field(name="is_priority_user", dtype=Bool),
+        Field(name="domain_category", dtype=String),
+    ],
+)
+def enriched_prediction(inputs: pd.DataFrame) -> pd.DataFrame:
+    """Multi-artifact feature transformation."""
+    global _sentiment_model, _lookup_tables, _config
+
+    results = []
+    for i, row in inputs.iterrows():
+        text = row["input_text"]
+        user_id = row["user_id"]
+        domain = row.get("domain", "")
+
+        # Use pre-loaded model
+        predictions = _sentiment_model(text)
+        sentiment_scores = {pred["label"]: pred["score"] for pred in predictions}
+
+        # Use lookup tables
+        predicted_sentiment = _lookup_tables["sentiment_labels"].get(
+            max(sentiment_scores, key=sentiment_scores.get),
+            _config["default_sentiment"]
+        )
+
+        is_priority = user_id in _lookup_tables["priority_users"]
+        category = _lookup_tables["domain_categories"].get(domain, "unknown")
+
+        results.append({
+            "predicted_sentiment": predicted_sentiment,
+            "is_priority_user": is_priority,
+            "domain_category": category,
+        })
+
+    return pd.DataFrame(results)
+```
+
+## Container Deployment
+
+Static artifacts work with containerized deployments. Include your artifacts in the container image:
+
+```dockerfile
+FROM python:3.11-slim
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+# Copy feature repository including static_artifacts.py
+COPY feature_repo/ /app/feature_repo/
+
+WORKDIR /app/feature_repo
+
+# Start feature server
+CMD ["feast", "serve", "--host", "0.0.0.0"]
+```
+
+The server will automatically load static artifacts during container startup.
+
+## Supported Artifact Types
+
+### Recommended Artifacts
+- **Small ML models**: Sentiment analysis, text classification, small neural networks
+- **Lookup tables**: Label mappings, category dictionaries, user segments
+- **Configuration data**: Model parameters, feature mappings, business rules
+- **Pre-computed embeddings**: User vectors, item features, static representations
+
+### Not Recommended
+- **Large Language Models**: Use dedicated serving solutions (vLLM, TensorRT-LLM, TGI)
+- **Models requiring specialized hardware**: GPU clusters, TPUs
+- **Frequently updated models**: Consider model registries with versioning
+- **Large datasets**: Use feature views with proper data sources instead
+
+## Error Handling
+
+Static artifacts loading includes graceful error handling:
+- **Missing file**: Server starts normally without static artifacts
+- **Loading errors**: Warnings are logged, feature views should implement fallback logic
+- **Partial failures**: Successfully loaded artifacts remain available
+
+Always implement fallback behavior in your feature transformations:
+
+```python
+@on_demand_feature_view(...)
+def robust_prediction(inputs: pd.DataFrame) -> pd.DataFrame:
+    global _sentiment_model
+
+    results = []
+    for text in inputs["input_text"]:
+        if _sentiment_model is not None:
+            # Use pre-loaded model
+            predictions = _sentiment_model(text)
+            sentiment = max(predictions, key=lambda x: x["score"])["label"]
+        else:
+            # Fallback when artifacts aren't available
+            sentiment = "neutral"
+
+        results.append({"predicted_sentiment": sentiment})
+
+    return pd.DataFrame(results)
+```
+
+## Starting the Feature Server
+
+Start the feature server as usual:
+
+```bash
+feast serve
+```
+
+You'll see log messages indicating artifact loading:
+
+```
+INFO:fastapi:Loading static artifacts from static_artifacts.py
+INFO:fastapi:Static artifacts loading completed
+INFO:uvicorn:Application startup complete
+```
+
+## Template Example
+
+The PyTorch NLP template demonstrates static artifacts loading:
+
+```bash
+feast init my-nlp-project -t pytorch_nlp
+cd my-nlp-project/feature_repo
+feast serve
+```
+
+This template includes a complete example with sentiment analysis model loading, lookup tables, and integration with on-demand feature views.
+
+## Performance Considerations
+
+- **Startup time**: Artifacts are loaded during server initialization, which may increase startup time
+- **Memory usage**: All artifacts remain in memory for the server's lifetime
+- **Concurrency**: Artifacts are shared across all request threads
+- **Container resources**: Ensure sufficient memory allocation for your artifacts
+
+## Configuration
+
+Currently, static artifacts loading uses convention-based configuration:
+- **File name**: Must be named `static_artifacts.py`
+- **Location**: Must be in the feature repository root directory
+- **Function name**: Must implement `load_artifacts(app: FastAPI)` function
+
+## Limitations
+
+- File name and location are currently fixed (not configurable)
+- Artifacts are loaded synchronously during startup
+- No built-in artifact versioning or hot reloading
+- Limited to Python-based artifacts (no external binaries)
+
+## Contributing
+
+This is an alpha feature and we welcome contributions! Areas for improvement:
+- Configurable artifact file locations
+- Asynchronous artifact loading
+- Built-in artifact versioning
+- Performance monitoring and metrics
+- Integration with model registries
+
+Please report issues and contribute improvements via the [Feast GitHub repository](https://github.com/feast-dev/feast).
\ No newline at end of file
diff --git a/docs/reference/feature-servers/python-feature-server.md b/docs/reference/feature-servers/python-feature-server.md
index f8e121ad6af..df0b0b1f78d 100644
--- a/docs/reference/feature-servers/python-feature-server.md
+++ b/docs/reference/feature-servers/python-feature-server.md
@@ -268,6 +268,48 @@ To start the feature server in TLS mode, you need to provide the private and pub
 feast serve --key /path/to/key.pem --cert /path/to/cert.pem
 ```
 
+# [Alpha] Static Artifacts Loading
+
+**Warning**: This is an experimental feature. To our knowledge, this is stable, but there are still rough edges in the experience.
+
+Static artifacts loading allows you to load models, lookup tables, and other static resources once during feature server startup instead of loading them on each request. This improves performance for on-demand feature views that require external resources.
+
+## Quick Example
+
+Create a `static_artifacts.py` file in your feature repository:
+
+```python
+# static_artifacts.py
+from fastapi import FastAPI
+from transformers import pipeline
+
+def load_artifacts(app: FastAPI):
+    """Load static artifacts into app.state."""
+    app.state.sentiment_model = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
+
+    # Update global references for access from feature views
+    import example_repo
+    example_repo._sentiment_model = app.state.sentiment_model
+```
+
+Access pre-loaded artifacts in your on-demand feature views:
+
+```python
+# example_repo.py
+_sentiment_model = None
+
+@on_demand_feature_view(...)
+def sentiment_prediction(inputs: pd.DataFrame) -> pd.DataFrame:
+    global _sentiment_model
+    return _sentiment_model(inputs["text"])
+```
+
+## Documentation
+
+For comprehensive documentation, examples, and best practices, see the [Alpha Static Artifacts Loading](../alpha-static-artifacts.md) reference guide.
+
+The [PyTorch NLP template](https://github.com/feast-dev/feast/tree/main/sdk/python/feast/templates/pytorch_nlp) provides a complete working example.
+
 # Online Feature Server Permissions and Access Control
 
 ## API Endpoints and Permissions
diff --git a/sdk/python/feast/feature_server.py b/sdk/python/feast/feature_server.py
index e3ec16496cc..fbbb38821af 100644
--- a/sdk/python/feast/feature_server.py
+++ b/sdk/python/feast/feature_server.py
@@ -155,6 +155,52 @@ async def _get_features(
     return features
 
 
+async def load_static_artifacts(app: FastAPI, store):
+    """
+    Load static artifacts (models, lookup tables, etc.) into app.state.
+
+    This function can be extended to load various types of static artifacts:
+    - Small ML models (scikit-learn, small neural networks)
+    - Lookup tables and reference data
+    - Configuration parameters
+    - Pre-computed embeddings
+
+    Note: Not recommended for large language models - use dedicated
+    model serving solutions (vLLM, TGI, etc.) for those.
+    """
+    try:
+        # Import here to avoid loading heavy dependencies unless needed
+        import importlib.util
+        import inspect
+        from pathlib import Path
+
+        # Look for static artifacts loading in the feature repository
+        # This allows templates and users to define their own artifact loading
+        repo_path = Path(store.repo_path) if store.repo_path else Path.cwd()
+        artifacts_file = repo_path / "static_artifacts.py"
+
+        if artifacts_file.exists():
+            # Load and execute custom static artifacts loading
+            spec = importlib.util.spec_from_file_location(
+                "static_artifacts", artifacts_file
+            )
+            if spec and spec.loader:
+                artifacts_module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(artifacts_module)
+
+                # Look for load_artifacts function
+                if hasattr(artifacts_module, "load_artifacts"):
+                    load_func = artifacts_module.load_artifacts
+                    if inspect.iscoroutinefunction(load_func):
+                        await load_func(app)
+                    else:
+                        load_func(app)
+                    logger.info("Loaded static artifacts from static_artifacts.py")
+    except Exception as e:
+        # Non-fatal error - feature server should still start
+        logger.warning(f"Failed to load static artifacts: {e}")
+
+
 def get_app(
     store: "feast.FeatureStore",
     registry_ttl_sec: int = DEFAULT_FEATURE_SERVER_REGISTRY_TTL,
@@ -217,6 +263,9 @@ def async_refresh():
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):
+        # Load static artifacts before initializing store
+        await load_static_artifacts(app, store)
+
         await store.initialize()
         async_refresh()
         yield
diff --git a/sdk/python/feast/templates/pytorch_nlp/README.md b/sdk/python/feast/templates/pytorch_nlp/README.md
index 3d9babbd232..7fe0e0e708d 100644
--- a/sdk/python/feast/templates/pytorch_nlp/README.md
+++ b/sdk/python/feast/templates/pytorch_nlp/README.md
@@ -157,7 +157,8 @@ my-sentiment-project/
 ├── README.md                     # This file
 └── feature_repo/
     ├── feature_store.yaml        # Feast configuration
-    ├── example_repo.py           # Feature definitions
+    ├── example_repo.py           # Feature definitions (uses pre-loaded artifacts)
+    ├── static_artifacts.py       # Static artifacts loading (models, lookup tables)
     ├── test_workflow.py          # Complete demo workflow
     └── data/                     # Generated sample data
         └── sentiment_data.parquet
@@ -205,6 +206,109 @@ offline_store:
 - ✅ **No external services** - No Redis/cloud required
 - ✅ **Perfect for demos** - Easy to share and understand
 
+## 🚀 Static Artifacts Loading
+
+This template demonstrates **static artifacts loading** - a performance optimization that loads models, lookup tables, and other artifacts once at feature server startup instead of on each request.
+
+### What are Static Artifacts?
+
+Static artifacts are pre-loaded resources that remain constant during server operation:
+- **Small ML models** (sentiment analysis, classification, small neural networks)
+- **Lookup tables and mappings** (label encoders, category mappings)
+- **Configuration data** (model parameters, feature mappings)
+- **Pre-computed embeddings** (user embeddings, item features)
+
+### Performance Benefits
+
+**Before (Per-Request Loading):**
+```python
+def sentiment_prediction(inputs):
+    # ❌ Model loads on every request - slow!
+    model = pipeline("sentiment-analysis", model="...")
+    return model(inputs["text"])
+```
+
+**After (Startup Loading):**
+```python
+# ✅ Model loads once at server startup
+def sentiment_prediction(inputs):
+    global _sentiment_model  # Pre-loaded model
+    return _sentiment_model(inputs["text"])
+```
+
+**Performance Impact:**
+- 🚀 **10-100x faster** inference (no model loading overhead)
+- 💾 **Lower memory usage** (shared model across requests)
+- ⚡ **Better scalability** (consistent response times)
+
+### How It Works
+
+1. **Startup**: Feast server loads `static_artifacts.py` during initialization
+2. **Loading**: `load_artifacts(app)` function stores models in `app.state`
+3. **Access**: On-demand feature views access pre-loaded artifacts via global references
+
+```python
+# static_artifacts.py - Define what to load
+def load_artifacts(app: FastAPI):
+    app.state.sentiment_model = load_sentiment_model()
+    app.state.lookup_tables = load_lookup_tables()
+
+    # Update global references for easy access
+    import example_repo
+    example_repo._sentiment_model = app.state.sentiment_model
+    example_repo._lookup_tables = app.state.lookup_tables
+
+# example_repo.py - Use pre-loaded artifacts
+_sentiment_model = None  # Set by static_artifacts.py
+
+def sentiment_prediction(inputs):
+    global _sentiment_model
+    if _sentiment_model is not None:
+        return _sentiment_model(inputs["text"])
+    else:
+        return fallback_predictions()
+```
+
+### Scope and Limitations
+
+**✅ Great for:**
+- Small to medium models (< 1GB)
+- Fast-loading models (sentiment analysis, classification)
+- Lookup tables and reference data
+- Configuration parameters
+- Pre-computed embeddings
+
+**❌ Not recommended for:**
+- **Large Language Models (LLMs)** - Use dedicated serving solutions like vLLM, TGI, or TensorRT-LLM
+- Models requiring GPU clusters
+- Frequently updated models
+- Models with complex initialization dependencies
+
+**Note:** Feast is optimized for feature serving, not large model inference. For production LLM workloads, use specialized model serving platforms.
+
+### Customizing Static Artifacts
+
+To add your own artifacts, modify `static_artifacts.py`:
+
+```python
+def load_custom_embeddings():
+    """Load pre-computed user embeddings."""
+    embeddings_file = Path(__file__).parent / "data" / "user_embeddings.npy"
+    if embeddings_file.exists():
+        import numpy as np
+        return {"embeddings": np.load(embeddings_file)}
+    return None
+
+def load_artifacts(app: FastAPI):
+    # Load your custom artifacts
+    app.state.custom_embeddings = load_custom_embeddings()
+    app.state.config_params = {"threshold": 0.7, "top_k": 10}
+
+    # Make them available to feature views
+    import example_repo
+    example_repo._custom_embeddings = app.state.custom_embeddings
+```
+
 ## 📚 Detailed Usage
 
 ### 1. Feature Store Setup
@@ -409,20 +513,21 @@ def toxicity_detection(inputs: pd.DataFrame) -> pd.DataFrame:
 ### Performance Optimization
 
 **Current Architecture:**
-- Models load on each request (see `sentiment_prediction` function)
+- ✅ **Static artifacts loading** at server startup (see `static_artifacts.py`)
+- ✅ **Pre-loaded models** cached in memory for fast inference
 - CPU-only operation to avoid multiprocessing issues
 - SQLite-based storage for fast local access
 
-**TODO: Optimization Opportunities:**
-- **Startup-time Model Loading**: Load models once at server startup instead of per-request
-- **Custom Provider**: Implement model caching via custom Feast provider
-- **Model Serving Layer**: Use dedicated model servers (TorchServe, MLflow) for heavy models
+**Implemented Optimizations:**
+- **Startup-time Model Loading**: ✅ Models load once at server startup via `static_artifacts.py`
+- **Memory-efficient Caching**: ✅ Models stored in `app.state` and accessed via global references
+- **Fallback Handling**: ✅ Graceful degradation when artifacts fail to load
 
-**Production Optimizations:**
-1. **Model Caching**: Cache loaded models in memory to avoid repeated loading
-2. **Batch Inference**: Process multiple texts together for efficiency
-3. **Feature Materialization**: Pre-compute expensive features offline
-4. **Async Processing**: Use async patterns for real-time serving
+**Additional Production Optimizations:**
+1. **Batch Inference**: Process multiple texts together for efficiency
+2. **Feature Materialization**: Pre-compute expensive features offline
+3. **Async Processing**: Use async patterns for real-time serving
+4. **Model Serving Layer**: Use dedicated model servers (TorchServe, vLLM) for large models
 
 ### Production Configuration Examples
 
diff --git a/sdk/python/feast/templates/pytorch_nlp/feature_repo/example_repo.py b/sdk/python/feast/templates/pytorch_nlp/feature_repo/example_repo.py
index e78614aacea..ee49bea2899 100644
--- a/sdk/python/feast/templates/pytorch_nlp/feature_repo/example_repo.py
+++ b/sdk/python/feast/templates/pytorch_nlp/feature_repo/example_repo.py
@@ -25,6 +25,18 @@
 from feast.on_demand_feature_view import on_demand_feature_view
 from feast.types import Array, Float32, Int64, String
 
+try:
+    # Import static artifacts helpers (available when feature server loads artifacts)
+    from static_artifacts import get_lookup_tables, get_sentiment_model
+except ImportError:
+    # Fallback for when static_artifacts.py is not available
+    get_sentiment_model = None
+    get_lookup_tables = None
+
+# Global references for static artifacts (set by feature server)
+_sentiment_model = None
+_lookup_tables: dict = {}
+
 # Configuration
 repo_path = Path(__file__).parent
 data_path = repo_path / "data"
@@ -143,76 +155,67 @@
 )
 def sentiment_prediction(inputs: pd.DataFrame) -> pd.DataFrame:
     """
-    Real-time sentiment prediction using pre-trained models.
+    Real-time sentiment prediction using pre-loaded static artifacts.
 
-    This function demonstrates how to integrate PyTorch/HuggingFace models
-    directly into Feast feature views for real-time inference.
+    This function demonstrates how to use static artifacts (pre-loaded models,
+    lookup tables) for efficient real-time inference. Models are loaded once
+    at feature server startup rather than on each request.
     """
     try:
         import numpy as np
-        from transformers import pipeline
     except ImportError:
-        # Fallback to dummy predictions if dependencies aren't available
-        df = pd.DataFrame()
-        df["predicted_sentiment"] = ["neutral"] * len(inputs)
-        df["sentiment_confidence"] = np.array([0.5] * len(inputs), dtype=np.float32)
-        df["positive_prob"] = np.array([0.33] * len(inputs), dtype=np.float32)
-        df["negative_prob"] = np.array([0.33] * len(inputs), dtype=np.float32)
-        df["neutral_prob"] = np.array([0.34] * len(inputs), dtype=np.float32)
-        df["text_embedding"] = [[np.float32(0.0)] * 384] * len(inputs)
-        return df
+        # Fallback to dummy predictions if numpy isn't available
 
-    # Initialize model (in production, you'd want to cache this)
-    model_name = "cardiffnlp/twitter-roberta-base-sentiment-latest"
-    try:
-        # Use sentiment pipeline for convenience (force CPU to avoid MPS forking issues)
-        sentiment_pipeline = pipeline(
-            "sentiment-analysis",
-            model=model_name,
-            tokenizer=model_name,
-            return_all_scores=True,
-            device="cpu",  # Force CPU to avoid MPS forking issues on macOS
-        )
-
-    except Exception:
-        # Fallback if model loading fails
         df = pd.DataFrame()
         df["predicted_sentiment"] = ["neutral"] * len(inputs)
-        df["sentiment_confidence"] = np.array([0.5] * len(inputs), dtype=np.float32)
-        df["positive_prob"] = np.array([0.33] * len(inputs), dtype=np.float32)
-        df["negative_prob"] = np.array([0.33] * len(inputs), dtype=np.float32)
-        df["neutral_prob"] = np.array([0.34] * len(inputs), dtype=np.float32)
-        df["text_embedding"] = [[np.float32(0.0)] * 384] * len(inputs)
+        df["sentiment_confidence"] = [0.5] * len(inputs)
+        df["positive_prob"] = [0.33] * len(inputs)
+        df["negative_prob"] = [0.33] * len(inputs)
+        df["neutral_prob"] = [0.34] * len(inputs)
+        df["text_embedding"] = [[0.0] * 384] * len(inputs)
         return df
 
+    # Get pre-loaded static artifacts from global references
+    # These are loaded once at startup via static_artifacts.py
+    global _sentiment_model, _lookup_tables
+
+    sentiment_model = _sentiment_model
+    lookup_tables = _lookup_tables
+
+    # Use lookup table for label mapping (from static artifacts)
+    label_map = lookup_tables.get(
+        "sentiment_labels",
+        {"LABEL_0": "negative", "LABEL_1": "neutral", "LABEL_2": "positive"},
+    )
+
     results = []
 
     for text in inputs["input_text"]:
         try:
-            # Get sentiment predictions
-            predictions = sentiment_pipeline(text)
-
-            # Parse results (RoBERTa model returns LABEL_0, LABEL_1, LABEL_2)
-            label_map = {
-                "LABEL_0": "negative",
-                "LABEL_1": "neutral",
-                "LABEL_2": "positive",
-            }
-
-            scores = {
-                label_map.get(pred["label"], pred["label"]): pred["score"]
-                for pred in predictions
-            }
-
-            # Get best prediction
-            best_pred = max(predictions, key=lambda x: x["score"])
-            predicted_sentiment = label_map.get(best_pred["label"], best_pred["label"])
-            confidence = best_pred["score"]
-
-            # Get embeddings (simplified - dummy embeddings for demo)
-            # In a real implementation, you'd run the model to get embeddings
-            # For this demo, we'll create a dummy embedding
-            embedding = np.random.rand(384).tolist()  # DistilBERT size
+            if sentiment_model is not None:
+                # Use pre-loaded model for prediction
+                predictions = sentiment_model(text)
+
+                # Parse results using static lookup tables
+                scores = {
+                    label_map.get(pred["label"], pred["label"]): pred["score"]
+                    for pred in predictions
+                }
+
+                # Get best prediction
+                best_pred = max(predictions, key=lambda x: x["score"])
+                predicted_sentiment = label_map.get(
+                    best_pred["label"], best_pred["label"]
+                )
+                confidence = best_pred["score"]
+            else:
+                # Fallback when model is not available
+                predicted_sentiment = "neutral"
+                confidence = 0.5
+                scores = {"positive": 0.33, "negative": 0.33, "neutral": 0.34}
+
+            # Generate dummy embeddings (in production, use pre-loaded embeddings)
+            embedding = np.random.rand(384).tolist()
 
             results.append(
                 {
diff --git a/sdk/python/feast/templates/pytorch_nlp/feature_repo/static_artifacts.py b/sdk/python/feast/templates/pytorch_nlp/feature_repo/static_artifacts.py
new file mode 100644
index 00000000000..6f7a5ae3091
--- /dev/null
+++ b/sdk/python/feast/templates/pytorch_nlp/feature_repo/static_artifacts.py
@@ -0,0 +1,139 @@
+"""
+Static Artifacts Loading for PyTorch NLP Template
+
+This module demonstrates how to load static artifacts (models, lookup tables, etc.)
+into the Feast feature server at startup for efficient real-time inference.
+
+Supported artifact types:
+- Small ML models (transformers, scikit-learn, etc.)
+- Lookup tables and reference data
+- Configuration parameters
+- Pre-computed embeddings
+
+Note: Feast is not optimized for large language models. For LLM inference,
+use dedicated model serving solutions like vLLM, TensorRT-LLM, or TGI.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI
+from fastapi.logger import logger
+
+
+def load_sentiment_model():
+    """Load sentiment analysis model for real-time inference."""
+    try:
+        from transformers import pipeline
+
+        logger.info("Loading sentiment analysis model...")
+        model = pipeline(
+            "sentiment-analysis",
+            model="cardiffnlp/twitter-roberta-base-sentiment-latest",
+            tokenizer="cardiffnlp/twitter-roberta-base-sentiment-latest",
+            return_all_scores=True,
+            device="cpu",  # Force CPU to avoid MPS forking issues on macOS
+        )
+        logger.info("✅ Sentiment analysis model loaded successfully")
+        return model
+    except ImportError:
+        logger.warning(
+            "⚠️ Transformers not available, sentiment model will use fallback"
+        )
+        return None
+    except Exception as e:
+        logger.warning(f"⚠️ Failed to load sentiment model: {e}")
+        return None
+
+
+def load_lookup_tables() -> Dict[str, Any]:
+    """Load static lookup tables for feature engineering."""
+    # Example: Load static mappings that are expensive to compute at request time
+    return {
+        "sentiment_labels": {
+            "LABEL_0": "negative",
+            "LABEL_1": "neutral",
+            "LABEL_2": "positive",
+        },
+        "emoji_sentiment": {"😊": "positive", "😞": "negative", "😐": "neutral"},
+        "domain_categories": {"twitter.com": "social", "news.com": "news"},
+    }
+
+
+def load_user_embeddings() -> Optional[Dict[str, Any]]:
+    """Load pre-computed user embeddings if available."""
+    # Example: Load static user embeddings for recommendation features
+    embeddings_file = Path(__file__).parent / "data" / "user_embeddings.npy"
+
+    if embeddings_file.exists():
+        try:
+            import numpy as np
+
+            embeddings = np.load(embeddings_file)
+            logger.info(f"✅ Loaded user embeddings: {embeddings.shape}")
+            return {"embeddings": embeddings}
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to load user embeddings: {e}")
+
+    return None
+
+
+def load_artifacts(app: FastAPI):
+    """
+    Main function called by Feast feature server to load static artifacts.
+
+    This function is called during server startup and should store artifacts
+    in app.state for access by on-demand feature views.
+    """
+    logger.info("🔄 Loading static artifacts for PyTorch NLP template...")
+
+    # Load sentiment analysis model
+    app.state.sentiment_model = load_sentiment_model()
+
+    # Load lookup tables
+    app.state.lookup_tables = load_lookup_tables()
+
+    # Load user embeddings (optional)
+    app.state.user_embeddings = load_user_embeddings()
+
+    # Also set global references for easier access from on-demand feature views
+    try:
+        import example_repo
+
+        example_repo._sentiment_model = app.state.sentiment_model
+        example_repo._lookup_tables = app.state.lookup_tables
+        logger.info("✅ Global artifact references updated")
+    except ImportError:
+        logger.warning("⚠️ Could not update global artifact references")
+
+    logger.info("✅ Static artifacts loading completed")
+
+
+def get_static_artifact(app_state: Any, name: str) -> Any:
+    """
+    Helper function to safely access static artifacts from app.state.
+
+    Args:
+        app_state: FastAPI app.state object
+        name: Name of the artifact to retrieve
+
+    Returns:
+        The requested artifact or None if not found
+    """
+    return getattr(app_state, name, None)
+
+
+# Convenience functions for accessing specific artifacts
+def get_sentiment_model(app_state: Any):
+    """Get the pre-loaded sentiment analysis model."""
+    return get_static_artifact(app_state, "sentiment_model")
+
+
+def get_lookup_tables(app_state: Any) -> Dict[str, Any]:
+    """Get the pre-loaded lookup tables."""
+    return get_static_artifact(app_state, "lookup_tables") or {}
+
+
+def get_user_embeddings(app_state: Any):
+    """Get the pre-loaded user embeddings."""
+    return get_static_artifact(app_state, "user_embeddings")
diff --git a/sdk/python/tests/unit/test_feature_server.py b/sdk/python/tests/unit/test_feature_server.py
index 21c01d61765..e3fd0387fb9 100644
--- a/sdk/python/tests/unit/test_feature_server.py
+++ b/sdk/python/tests/unit/test_feature_server.py
@@ -207,3 +207,204 @@ def test_materialize_request_model():
     assert req2.disable_event_timestamp is False
     assert req2.start_ts == "2021-01-01T00:00:00"
     assert req2.end_ts == "2021-01-02T00:00:00"
+
+
+# Static Artifacts Tests
+@pytest.fixture
+def mock_store_with_static_artifacts(tmp_path):
+    """Create a mock store with static_artifacts.py file for testing."""
+    # Create static_artifacts.py file
+    static_artifacts_content = '''
+from fastapi import FastAPI
+from fastapi.logger import logger
+
+def load_test_model():
+    """Mock model loading for testing."""
+    logger.info("Loading test model...")
+    return "test_model_loaded"
+
+def load_test_lookup_tables():
+    """Mock lookup tables for testing."""
+    return {"test_label": "test_value"}
+
+def load_artifacts(app: FastAPI):
+    """Load test static artifacts."""
+    app.state.test_model = load_test_model()
+    app.state.test_lookup_tables = load_test_lookup_tables()
+    logger.info("✅ Test static artifacts loaded")
+'''
+
+    # Write static_artifacts.py to temp directory
+    artifacts_file = tmp_path / "static_artifacts.py"
+    artifacts_file.write_text(static_artifacts_content)
+
+    # Create mock store
+    mock_store = MagicMock()
+    mock_store.repo_path = str(tmp_path)
+    return mock_store
+
+
+def test_load_static_artifacts_success(mock_store_with_static_artifacts):
+    """Test successful loading of static artifacts during server startup."""
+    import asyncio
+
+    from fastapi import FastAPI
+
+    from feast.feature_server import load_static_artifacts
+
+    app = FastAPI()
+
+    # Load static artifacts
+    asyncio.run(load_static_artifacts(app, mock_store_with_static_artifacts))
+
+    # Verify artifacts were loaded into app.state
+    assert hasattr(app.state, "test_model")
+    assert hasattr(app.state, "test_lookup_tables")
+    assert app.state.test_model == "test_model_loaded"
+    assert app.state.test_lookup_tables == {"test_label": "test_value"}
+
+
+def test_load_static_artifacts_no_file(tmp_path):
+    """Test graceful handling when static_artifacts.py doesn't exist."""
+    import asyncio
+
+    from fastapi import FastAPI
+
+    from feast.feature_server import load_static_artifacts
+
+    app = FastAPI()
+    mock_store = MagicMock()
+    mock_store.repo_path = str(tmp_path)  # Empty directory
+
+    # Should not raise an exception
+    asyncio.run(load_static_artifacts(app, mock_store))
+
+    # Should not have added test artifacts
+    assert not hasattr(app.state, "test_model")
+    assert not hasattr(app.state, "test_lookup_tables")
+
+
+def test_load_static_artifacts_invalid_file(tmp_path):
+    """Test graceful handling when static_artifacts.py has errors."""
+    import asyncio
+
+    from fastapi import FastAPI
+
+    from feast.feature_server import load_static_artifacts
+
+    # Create invalid static_artifacts.py
+    artifacts_file = tmp_path / "static_artifacts.py"
+    artifacts_file.write_text("raise ValueError('Test error')")
+
+    app = FastAPI()
+    mock_store = MagicMock()
+    mock_store.repo_path = str(tmp_path)
+
+    # Should handle the error gracefully
+    asyncio.run(load_static_artifacts(app, mock_store))
+
+    # Should not have artifacts due to error
+    assert not hasattr(app.state, "test_model")
+
+
+def test_load_static_artifacts_no_load_function(tmp_path):
+    """Test handling when static_artifacts.py has no load_artifacts function."""
+    import asyncio
+
+    from fastapi import FastAPI
+
+    from feast.feature_server import load_static_artifacts
+
+    # Create static_artifacts.py without load_artifacts function
+    artifacts_file = tmp_path / "static_artifacts.py"
+    artifacts_file.write_text("TEST_CONSTANT = 'test'")
+
+    app = FastAPI()
+    mock_store = MagicMock()
+    mock_store.repo_path = str(tmp_path)
+
+    # Should handle gracefully
+    asyncio.run(load_static_artifacts(app, mock_store))
+
+    # Should not have artifacts since no load_artifacts function
+    assert not hasattr(app.state, "test_model")
+
+
+def test_static_artifacts_persist_across_requests(mock_store_with_static_artifacts):
+    """Test that static artifacts persist across multiple requests."""
+    from feast.feature_server import get_app
+
+    # Create app with static artifacts
+    app = get_app(mock_store_with_static_artifacts)
+
+    # Simulate artifacts being loaded (normally done in lifespan)
+    app.state.test_model = "persistent_model"
+    app.state.test_lookup_tables = {"persistent": "data"}
+
+    # Artifacts should be available and persistent
+    assert app.state.test_model == "persistent_model"
+    assert app.state.test_lookup_tables["persistent"] == "data"
+
+    # After simulated requests, artifacts should still be there
+    assert app.state.test_model == "persistent_model"
+    assert app.state.test_lookup_tables["persistent"] == "data"
+
+
+def test_pytorch_nlp_template_artifacts_pattern(tmp_path):
+    """Test the specific PyTorch NLP template static artifacts pattern."""
+    import asyncio
+
+    from fastapi import FastAPI
+
+    from feast.feature_server import load_static_artifacts
+
+    # Create PyTorch NLP template-style static_artifacts.py
+    pytorch_artifacts_content = '''
+from fastapi import FastAPI
+from fastapi.logger import logger
+
+def load_sentiment_model():
+    """Mock sentiment analysis model loading."""
+    logger.info("Loading sentiment analysis model...")
+    return "mock_roberta_sentiment_model"
+
+def load_lookup_tables():
+    """Load lookup tables for sentiment mapping."""
+    return {
+        "sentiment_labels": {"LABEL_0": "negative", "LABEL_1": "neutral", "LABEL_2": "positive"},
+        "emoji_sentiment": {"😊": "positive", "😞": "negative", "😐": "neutral"},
+    }
+
+def load_artifacts(app: FastAPI):
+    """Load all static artifacts for PyTorch NLP template."""
+    app.state.sentiment_model = load_sentiment_model()
+    app.state.lookup_tables = load_lookup_tables()
+
+    # Update global references (simulating example_repo.py pattern)
+    # In real template, this would be: import example_repo; example_repo._sentiment_model = ...
+    logger.info("✅ PyTorch NLP static artifacts loaded successfully")
+'''
+
+    artifacts_file = tmp_path / "static_artifacts.py"
+    artifacts_file.write_text(pytorch_artifacts_content)
+
+    # Test loading
+    app = FastAPI()
+    mock_store = MagicMock()
+    mock_store.repo_path = str(tmp_path)
+
+    asyncio.run(load_static_artifacts(app, mock_store))
+
+    # Verify PyTorch NLP template artifacts
+    assert hasattr(app.state, "sentiment_model")
+    assert hasattr(app.state, "lookup_tables")
+    assert app.state.sentiment_model == "mock_roberta_sentiment_model"
+
+    # Verify lookup tables structure matches template
+    lookup_tables = app.state.lookup_tables
+    assert "sentiment_labels" in lookup_tables
+    assert "emoji_sentiment" in lookup_tables
+    assert lookup_tables["sentiment_labels"]["LABEL_0"] == "negative"
+    assert lookup_tables["sentiment_labels"]["LABEL_1"] == "neutral"
+    assert lookup_tables["sentiment_labels"]["LABEL_2"] == "positive"
+    assert lookup_tables["emoji_sentiment"]["😊"] == "positive"