[Doc] How-to: Doc update part 2 [skip-ci] (#3931)

## Description

add new how-to guide documentation structure
add how-to: develop to include different FLARE API,
add FLARE API evolution documentation page
add how to calculate Fed Stats
add how to calculate Convert ML/FL to FL
add how to do simulations
add production section ( deployments in aws, azure, monitoring,
interaction with Flare)


### Types of changes
<!--- Put an `x` in all the boxes that apply, and remove the not
applicable items -->
- [x] Non-breaking change (fix or new feature that would not break
existing functionality).
- [ ] Breaking change (fix or new feature that would cause existing
functionality to change).
- [ ] New tests added to cover the changes.
- [ ] Quick tests passed locally by running `./runtest.sh`.
- [ ] In-line docstrings updated.
- [ ] Documentation updated.

Author: chesterxgchen

docs/how-to-guide/develop.rst

@@ -0,0 +1,24 @@
+.. _how_to_develop_guide:
+
+####################
+How To Develop Guide
+####################
+
+How to install and turn existing stand-alone, centralized applications into federated learning applications.
+
+Installation Guide
+------------------
+.. toctree::
+   :maxdepth: 1
+
+   ../installation
+
+Federated Application
+---------------------
+
+.. toctree::
+   :maxdepth: 1
+   :glob:
+
+   develop/*
+

docs/how-to-guide/develop/different_flare_apis.rst

@@ -0,0 +1,100 @@
+.. _diff_api_guide:
+
+########################
+How to Use FLARE APIs
+########################
+
+When getting started with NVIDIA FLARE, one of the first decisions new users face is choosing which APIs to use.
+FLARE provides multiple API layers that have evolved over time to support different levels of abstraction—from
+high-level, ready-to-use workflows for common federated learning and analytics tasks, to lower-level, highly
+customizable APIs for advanced control over execution, orchestration, and security. These APIs are reflected
+across different FLARE examples, which can sometimes be confusing for new users when deciding where to start.
+This guide helps clarify the evolution of FLARE APIs and provides guidance on selecting the most appropriate
+API for your use case and development goals.
+
+The newer FLARE APIs—Client API, Job Recipe API, and Collab API (coming soon)—represent the latest stage in the
+evolution of the platform. They are designed primarily for data scientists and researchers, providing a simplified
+and intuitive interface that is sufficient for most common federated learning and federated analytics use cases.
+In contrast, the Controller/Executor APIs operate at a lower level and are intended for system integration,
+advanced customization, and platform-level extensions, where fine-grained control over execution flow, policies,
+and orchestration is required.
+
+
+Evolution of FLARE APIs
+=======================
+
+Before deciding which API layer to use, it helps to understand the available options.
+The diagrams below provide an overview. For a detailed history, see :ref:`api_evolution`.
+
+Server-side APIs
+----------------
+
+.. image:: ../../resources/server_side_apis.jpg
+    :height: 400
+
+Client-side APIs
+----------------
+
+.. image:: ../../resources/client_side_apis.jpg
+    :height: 400
+
+Client-Server Wiring APIs
+-------------------------
+
+.. image:: ../../resources/client_server_wiring_apis.jpg
+    :height: 400
+
+
+Which APIs to Use?
+==================
+
+We recommend using the following APIs depending on your role:
+
+Applied Data Scientists
+-----------------------
+
+For users focused on applying FL to their ML workflows with minimal complexity:
+
+- **Client**: Client API
+- **Server**: Built-in algorithm (FedAvg, FedProx, etc.)
+- **Wiring**: Job Recipe with built-in FL algorithms
+
+FL Researchers
+--------------
+
+For users developing new FL algorithms or customizing training logic:
+
+- **Client**: Collab API, Client API
+- **Server**: Collab API
+- **Wiring**: Job Recipe
+
+System Integrators
+------------------
+
+For users building custom integrations or extending the platform:
+
+- **Client**: Collab API, Executor API
+- **Server**: Collab API, Controller API
+- **Wiring**: Job Recipe
+
+
+Deprecated APIs
+===============
+
+The following APIs are deprecated and should be avoided in new projects:
+
+- **LearnerExecutor and Learner**: Use Client API instead
+- **ModelController**: Will be superseded by Collab API
+- **Job Template & CLI Job Template API**: Use Job Recipe API instead
+
+
+API References
+==============
+
+For detailed documentation on each API:
+
+- :ref:`client_api` - Client-side API for ML code integration
+- :ref:`job_recipe` - Programmatic job definition
+- :ref:`api_evolution` - Complete API evolution history
+- Collab API - Coming soon
+

docs/how-to-guide/develop/dl_to_fl_guide.rst

@@ -0,0 +1,111 @@
+.. _dl_to_fl_guide:
+
+##################################################
+How to Convert Deep Learning to Federated Learning
+##################################################
+
+This guide uses deep learning code as an example. Other traditional ML examples can be found in the
+hello-world example series. Assuming the dataset is ready for training, converting an existing stand-alone,
+centralized deep learning script to federated learning with NVIDIA FLARE involves the following steps:
+
+- **Step 1**: Decide what type of training workflow to use: round-robin (cyclic weight transfer) or scatter-and-gather (weighted
+  average). For example, we can use federated weighted averaging (FedAvg). This determines what server-side
+  code to run.
+
+- **Step 2**: Convert the training scripts into client-side local training scripts so that they can receive a global model,
+  perform local training, and send the newly updated local model back to the server.
+
+- **Step 3**: Connect the server aggregation algorithm (FedAvg) and client training code together to perform the
+  federated learning job.
+
+
+NVIDIA FLARE provides a set of API stacks for data scientists to perform the above steps:
+
+- **Step 1**: Data scientists can use existing federated learning algorithms such as FedAvg. For custom
+  algorithms, FLARE offers the Collab API to simplify development (coming soon). The ModelController API
+  is also available for advanced customization.
+
+- **Step 2**: You can use the FLARE Client API to convert DL to FL with just a few lines of code changes.
+
+- **Step 3**: We have the Job Recipe API that connects steps 1 and 2. For example, ``FedAvgRecipe``.
+
+Here are some code snippets from the :ref:`hello_pt` example. See the complete code and description there.
+
+Client Code with Client API
+---------------------------
+
+On the client side, the training workflow is:
+
+1. Receive the model from the FL server
+2. Perform local training on the received global model and/or evaluate it for model selection
+3. Send the updated model back to the FL server
+
+The client code (``client.py``) implements this workflow. The training code is almost identical to
+standard PyTorch training code—the only difference is a few lines to receive and send data to the server.
+
+Using NVIDIA FLARE's Client API, you can easily adapt centralized ML code for federated scenarios.
+The three essential methods are:
+
+- ``init()``: Initializes the NVIDIA FLARE Client API environment.
+- ``receive()``: Receives a model from the FL server.
+- ``send()``: Sends the model to the FL server.
+
+With these simple methods, developers can use the Client API
+to change their centralized training code to an FL scenario with
+five lines of code changes, as shown below:
+
+.. code-block:: python
+
+   import nvflare.client as flare
+
+   flare.init()                    # 1. Initialize FLARE Client API
+   input_model = flare.receive()   # 2. Receive model from FL server
+   params = input_model.params     # 3. Extract model parameters
+
+   # Original local training code
+   new_params = local_train(params)
+
+   output_model = flare.FLModel(params=new_params)  # 4. Wrap results in FLModel
+   flare.send(output_model)                         # 5. Send model to FL server
+
+
+Job Recipe
+----------
+
+The Job Recipe connects the client training script with the built-in federated averaging algorithm:
+
+.. code-block:: python
+
+   from nvflare.job_config.fed_avg_recipe import FedAvgRecipe
+   from nvflare.simulation import SimEnv
+
+   recipe = FedAvgRecipe(
+       name="hello-pt",
+       min_clients=n_clients,
+       num_rounds=num_rounds,
+       initial_model=SimpleNetwork(),
+       train_script="client.py",
+       train_args=f"--batch_size {batch_size}",
+   )
+
+   env = SimEnv(num_clients=n_clients, num_threads=n_clients)
+   recipe.execute(env=env)
+
+Save this code to ``job.py``.
+
+Run the Job
+-----------
+
+From the terminal, run the job script to execute in a simulation environment:
+
+.. code-block:: bash
+
+   python job.py
+
+
+References
+----------
+
+- :ref:`hello_pt` - Complete example with full source code
+- :ref:`client_api` - Detailed Client API documentation
+- :ref:`job_recipe` - Job Recipe API documentation

docs/how-to-guide/develop/fed_analytics.rst

@@ -0,0 +1,130 @@
+.. _fed_analytics_guide:
+
+####################################
+How to Calculate Federated Analytics
+####################################
+
+NVIDIA FLARE enables collaborative data analysis across multiple sites without sharing raw data. Federated Analytics
+focuses on computing global statistics (such as counts, distributions, and means) by aggregating local analytics results
+computed at each participant.
+
+When to Use Federated Analytics
+================================
+
+Use Federated Analytics when you want to:
+
+- Understand data distribution and quality across institutions
+- Perform cohort discovery or feasibility analysis
+- Validate dataset compatibility before federated training
+
+Common outputs include:
+
+- Counts and histograms
+- Summary statistics (mean, sum, standard deviation)
+- Label or class distributions
+
+
+Overview
+========
+
+NVIDIA FLARE provides built-in federated statistics operators that generate global statistics based on local
+client-side statistics. At each client site, you can have one or more datasets (such as "train" and "test"),
+and each dataset may have many features. For each feature, the system calculates local statistics and then
+combines them to produce global statistics for all numeric features. The output includes complete statistics
+for all datasets across all clients, as well as global aggregates.
+
+The supported statistics include commonly used measures:
+
+- **count** - Number of samples
+- **sum** - Sum of values
+- **mean** - Average value (calculated from count and sum if both are selected)
+- **stddev** - Standard deviation
+- **histogram** - Distribution of values across bins
+- **quantile** - Percentile values (requires additional dependency)
+
+.. note::
+
+   We do not include min and max values to avoid data privacy concerns.
+   Only numerical features are supported; non-numerical features will be removed automatically.
+
+
+Steps to Implement
+==================
+
+1. Provide the target data source names (such as "train", "test") and the feature names
+2. Configure the target statistics metrics and output location
+3. Implement the local statistics generator using the ``Statistics`` spec and configure the client-side data input location
+
+For detailed instructions, see the :ref:`hello_tabular_stats` example.
+
+Example Configuration
+---------------------
+
+Here is an example statistics configuration:
+
+.. code-block:: text
+
+    statistic_configs = {
+        "count": {},
+        "mean": {},
+        "sum": {},
+        "stddev": {},
+        "histogram": {"*": {"bins": 20}, "Age": {"bins": 20, "range": [0, 100]}},
+        "quantile": {"*": [0.1, 0.5, 0.9]},
+    }
+
+This configuration specifies:
+
+- Calculate count, mean, sum, and stddev for all features
+- For histograms, use 20 bins with auto-calculated range, except "Age" which uses a fixed range of 0–100
+- For quantiles, calculate the 10%, 50% (median), and 90% percentiles for all features
+
+For tabular data, many required functions are implemented in ``DFStatisticsCore``, so data scientists
+only need to provide the data loader and configure the Job Recipe.
+
+
+Client Code
+-----------
+
+The local statistics generator ``AdultStatistics`` implements the ``Statistics`` spec:
+
+.. literalinclude:: ../../../examples/hello-world/hello-tabular-stats/client.py
+    :language: python
+    :linenos:
+    :caption: client.py
+    :lines: 14-
+
+The ``AdultStatistics`` class extends ``DFStatisticsCore`` and provides:
+
+- ``data_features``: Array of feature names
+- ``load_data()``: Returns a dictionary of Pandas DataFrames (one per data source)
+- ``data_path``: Path in the format ``<data_root_dir>/<site-name>/<filename>``
+
+
+Job Recipe
+----------
+
+The job is defined via a recipe and runs in the simulation environment:
+
+.. literalinclude:: ../../../examples/hello-world/hello-tabular-stats/job.py
+    :language: python
+    :linenos:
+    :caption: job.py
+    :lines: 14-
+
+
+Run the Job
+-----------
+
+From the terminal, run the job script:
+
+.. code-block:: bash
+
+    python job.py
+
+
+References
+----------
+
+- :ref:`hello_tabular_stats` - Complete tabular statistics example
+- :ref:`federated_statistics` - Detailed federated statistics documentation