diff --git a/pom.xml b/pom.xml
index 2eb0c234..a53eb2ea 100644
--- a/pom.xml
+++ b/pom.xml
@@ -101,6 +101,16 @@
 				<artifactId>gt-referencing</artifactId>
 				<version>${org.geotools.version}</version>
 			</dependency>
+            <dependency>
+                <groupId>org.geotools</groupId>
+                <artifactId>gt-wps</artifactId>
+                <version>${org.geotools.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.geotools</groupId>
+                <artifactId>gt-xml</artifactId>
+                <version>${org.geotools.version}</version>
+            </dependency>
 			<!--
 			https://mvnrepository.com/artifact/org.geotools/gt-epsg-hsql
 			it is use to lookup EPSG values
diff --git a/server/pom.xml b/server/pom.xml
index 2237b46b..2af661f8 100644
--- a/server/pom.xml
+++ b/server/pom.xml
@@ -154,6 +154,14 @@
             <groupId>org.geotools</groupId>
             <artifactId>gt-epsg-hsql</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.geotools</groupId>
+            <artifactId>gt-wps</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.geotools</groupId>
+            <artifactId>gt-xml</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.locationtech.spatial4j</groupId>
             <artifactId>spatial4j</artifactId>
@@ -225,6 +233,11 @@
             <version>1.5.0</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.xmlunit</groupId>
+            <artifactId>xmlunit-core</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <plugins>
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/model/ogc/FeatureRequest.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/model/ogc/FeatureRequest.java
index 227d0d0b..8e469c1a 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/model/ogc/FeatureRequest.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/model/ogc/FeatureRequest.java
@@ -1,5 +1,6 @@
 package au.org.aodn.ogcapi.server.core.model.ogc;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
@@ -15,19 +16,6 @@
 @NoArgsConstructor(force = true, access = AccessLevel.PROTECTED)    // Need when using @SuperBuilder
 @EqualsAndHashCode
 public class FeatureRequest implements Serializable {
-    // Define a fix name for fields, the geoserver data have all sorts of different name,
-    // map it here so that we hide the complexity of call from UI.
-    public enum PropertyName {
-        wildcard,
-        time;
-
-        public static PropertyName fromString(String input) {
-            if (input == null || "*".equals(input.trim())) {
-                return wildcard;  // or throw exception / return default
-            }
-            return valueOf(input.trim());
-        }
-    }
 
     @Getter
     public enum GeoServerOutputFormat {
@@ -67,7 +55,7 @@ public String toString() {
     }
 
     @Schema(description = "Property to be return")
-    private List<PropertyName> properties;
+    private List<String> properties;
 
     @Schema(description = "Only records that have a geometry that intersects the bounding box are selected. The bounding box is provided as four or six numbers, depending on whether the coordinate reference system includes a vertical axis (height or depth):  * Lower left corner, coordinate axis 1 * Lower left corner, coordinate axis 2 * Minimum value, coordinate axis 3 (optional) * Upper right corner, coordinate axis 1 * Upper right corner, coordinate axis 2 * Maximum value, coordinate axis 3 (optional)  The coordinate reference system of the values is WGS 84 long/lat (http://www.opengis.net/def/crs/OGC/1.3/CRS84) unless a different coordinate reference system is specified in the parameter `bbox-crs`.  For WGS 84 longitude/latitude the values are in most cases the sequence of minimum longitude, minimum latitude, maximum longitude and maximum latitude.  However, in cases where the box spans the antimeridian the first value (west-most box edge) is larger than the third value (east-most box edge).  If the vertical axis is included, the third and the sixth number are the bottom and the top of the 3-dimensional bounding box.  If a record has multiple spatial geometry properties, it is the decision of the server whether only a single spatial geometry property is used to determine the extent or all relevant geometries.")
     private List<BigDecimal> bbox;
@@ -90,6 +78,9 @@ public String toString() {
     @Schema(description = "Y")
     private BigDecimal y;
 
+    @Schema(description = "GeoJson MultiPolygon")
+    private Object multiPolygon;
+
     @Schema(description = "Data output format")
     private GeoServerOutputFormat outputFormat;
 
@@ -107,4 +98,22 @@ public String toString() {
     public Boolean getEnableGeoServerWhiteList() {
         return enableGeoServerWhiteList != null ? enableGeoServerWhiteList : Boolean.TRUE;
     }
+    /**
+     * date time must be of ogc format xxx/yyy or ../yyy or /yyy or xxx/.. or xxx/ etc
+     * @return The first part represent start date, null for unspecify.
+     */
+    @JsonIgnore
+    public String getStartDateTime() {
+        return (datetime == null || (datetime.startsWith("../") || datetime.startsWith("/"))) ?
+            null : datetime.split("/")[0];
+    }
+    /**
+     * date time must be of ogc format xxx/yyy or ../yyy or /yyy or xxx/.. or xxx/ etc
+     * @return The end part represent end date, null for unspecify.
+     */
+    @JsonIgnore
+    public String getEndDateTime() {
+        return (datetime == null || (datetime.endsWith("/..") || datetime.endsWith("/"))) ?
+                null : datetime.split("/")[1];
+    }
 }
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/ElasticSearch.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/ElasticSearch.java
index 0cf25a78..5dc30e36 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/ElasticSearch.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/ElasticSearch.java
@@ -633,7 +633,7 @@ protected static FieldValue toFieldValue(String s) {
 //    }
 
     @Override
-    public SearchResult<FeatureGeoJSON> searchFeatureSummary(String collectionId, List<FeatureRequest.PropertyName> properties, String filter) {
+    public SearchResult<FeatureGeoJSON> searchFeatureSummary(String collectionId, List<String> properties, String filter) {
         try {
             SearchRequest searchRequest = new SearchRequest.Builder()
                     .index(dataIndexName)
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/OGCApiService.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/OGCApiService.java
index 7242cd89..83a9b147 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/OGCApiService.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/OGCApiService.java
@@ -41,7 +41,7 @@ public abstract class OGCApiService {
 
     public ResponseEntity<FeatureCollectionGeoJSON> getFeature(String collectionId,
                                                                FeatureId fid,
-                                                               List<FeatureRequest.PropertyName> properties,
+                                                               List<String> properties,
                                                                String filter) throws Exception {
         switch(fid) {
             case summary -> {
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/Search.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/Search.java
index 2cf4b995..9420d2ad 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/Search.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/Search.java
@@ -18,7 +18,7 @@ public interface Search {
     ElasticSearchBase.SearchResult<StacCollectionModel> searchCollections(String id);
     ElasticSearchBase.SearchResult<StacCollectionModel> searchCollections(List<String> ids, String sortBy);
     ElasticSearchBase.SearchResult<StacCollectionModel> searchAllCollections(String sortBy) throws Exception;
-    ElasticSearchBase.SearchResult<FeatureGeoJSON>searchFeatureSummary(String collectionId, List<FeatureRequest.PropertyName> properties, String filter) throws Exception;
+    ElasticSearchBase.SearchResult<FeatureGeoJSON>searchFeatureSummary(String collectionId, List<String> properties, String filter) throws Exception;
 
     ElasticSearchBase.SearchResult<StacCollectionModel> searchByParameters(
             List<String> targets,
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/Server.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/Server.java
index fcab443c..f2deb3a0 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/Server.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/Server.java
@@ -1,87 +1,7 @@
 package au.org.aodn.ogcapi.server.core.service.geoserver;
 
-import au.org.aodn.ogcapi.server.core.model.ogc.wfs.WfsField;
-import au.org.aodn.ogcapi.server.core.model.ogc.wfs.WfsFields;
-import au.org.aodn.ogcapi.server.core.service.geoserver.wfs.WfsServer;
-import au.org.aodn.ogcapi.server.core.util.DatetimeUtils;
-import au.org.aodn.ogcapi.server.core.util.GeometryUtils;
-import lombok.extern.slf4j.Slf4j;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-@Slf4j
-public abstract class Server {
-    protected WfsServer wfsServer;
-
-    public Server(WfsServer wfsServer) {
-        this.wfsServer = wfsServer;
-    }
-    /**
-     * Build CQL filter for temporal and spatial constraints
-     */
-    protected String buildCqlFilter(String wfsServerUrl, String uuid, String layerName, String sd, String ed, Object multiPolygon) {
-
-        WfsFields wfsFieldModel = wfsServer.getDownloadableFields(
-                uuid,
-                WfsServer.WfsFeatureRequest.builder()
-                        .layerName(layerName)
-                        .server(wfsServerUrl)
-                        .build()
-        );
-        log.debug("WFSFieldModel by wfs typename: {}", wfsFieldModel);
-
-        // Validate start and end dates
-        final String startDate = DatetimeUtils.validateAndFormatDate(sd, true);
-        final String endDate = DatetimeUtils.validateAndFormatDate(ed, false);
-
-        StringBuilder cqlFilter = new StringBuilder();
-
-        if (wfsFieldModel == null || wfsFieldModel.getFields() == null) {
-            return cqlFilter.toString();
-        }
-
-        List<WfsField> fields = wfsFieldModel.getFields();
-
-        // Possible to have multiple days, better to consider all
-        List<WfsField> temporalField = fields.stream()
-                .filter(field -> "dateTime".equals(field.getType()) || "date".equals(field.getType()))
-                .toList();
-
-        // Add temporal filter only if both dates are specified
-        if (!temporalField.isEmpty() && startDate != null && !startDate.isEmpty() && endDate != null && !endDate.isEmpty()) {
-            List<String> cqls = new ArrayList<>();
-            temporalField.forEach(temp ->
-                    cqls.add(String.format("(%s DURING %sT00:00:00Z/%sT23:59:59Z)", temp.getName(), startDate, endDate))
-            );
-            cqlFilter.append("(").append(String.join(" OR ", cqls)).append(")");
-        }
-
-        // Find geometry field
-        Optional<WfsField> geometryField = fields.stream()
-                .filter(field -> "geometrypropertytype".equalsIgnoreCase(field.getType()))
-                .findFirst();
-
-        // Add spatial filter
-        if (geometryField.isPresent() && multiPolygon != null) {
-            String fieldName = geometryField.get().getName();
-
-            String wkt = GeometryUtils.convertToWkt(multiPolygon);
-
-            if ((wkt != null) && !cqlFilter.isEmpty()) {
-                cqlFilter.append(" AND ");
-            }
-
-            if (wkt != null) {
-                cqlFilter.append("INTERSECTS(")
-                        .append(fieldName)
-                        .append(",")
-                        .append(wkt)
-                        .append(")");
-            }
-        }
-
-        return cqlFilter.toString();
-    }
+/**
+ * Common interface for GeoServer component, we need to refactor and move common function here later
+ */
+public interface Server {
 }
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataService.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataService.java
index 20873aa3..29933608 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataService.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataService.java
@@ -1,7 +1,7 @@
 package au.org.aodn.ogcapi.server.core.service.geoserver.wfs;
 
 import au.org.aodn.ogcapi.server.core.model.ogc.FeatureRequest;
-import au.org.aodn.ogcapi.server.core.service.geoserver.Server;
+import au.org.aodn.ogcapi.server.core.util.DatetimeUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Value;
@@ -18,7 +18,8 @@
 
 @Slf4j
 @Service
-public class DownloadWfsDataService extends Server {
+public class DownloadWfsDataService {
+    private final WfsServer wfsServer;
     private final RestTemplate restTemplate;
     private final HttpEntity<?> pretendUserEntity;
     private final int chunkSize;
@@ -29,7 +30,7 @@ public DownloadWfsDataService(
             @Qualifier("pretendUserEntity") HttpEntity<?> pretendUserEntity,
             @Value("${app.sse.chunkSize:16384}") int chunkSize
     ) {
-        super(wfsServer);
+        this.wfsServer = wfsServer;
         this.restTemplate = restTemplate;
         this.pretendUserEntity = pretendUserEntity;
         this.chunkSize = chunkSize;
@@ -54,15 +55,19 @@ public String prepareWfsRequestUrl(
         if (featureServerUrl.isPresent()) {
             String wfsServerUrl = featureServerUrl.get();
 
-            // Build CQL filter
-            String cqlFilter = buildCqlFilter(wfsServerUrl, uuid, layerName, startDate, endDate, multiPolygon);
+            WfsServer.WfsFeatureRequest featureRequest = WfsServer.WfsFeatureRequest.builder()
+                    .server(wfsServerUrl)
+                    .layerName(layerName)
+                    .datetime(DatetimeUtils.formatOGCDateTime(startDate, endDate))
+                    .multiPolygon(multiPolygon)
+                    .build();
 
             // Build final WFS request URL
             String wfsRequestUrl = wfsServer.createWfsRequestUrl(
                     wfsServerUrl,
                     layerName,
                     fields,
-                    cqlFilter,
+                    wfsServer.buildCqlFilter(uuid, featureRequest),
                     outputFormat);
 
             log.info("Prepared WFS request URL: {}", wfsRequestUrl);
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/WfsServer.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/WfsServer.java
index 81e87a7c..e8ad629d 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/WfsServer.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/WfsServer.java
@@ -8,6 +8,9 @@
 import au.org.aodn.ogcapi.server.core.model.ogc.wfs.*;
 import au.org.aodn.ogcapi.server.core.service.ElasticSearchBase;
 import au.org.aodn.ogcapi.server.core.service.Search;
+import au.org.aodn.ogcapi.server.core.service.geoserver.Server;
+import au.org.aodn.ogcapi.server.core.util.DatetimeUtils;
+import au.org.aodn.ogcapi.server.core.util.GeometryUtils;
 import au.org.aodn.ogcapi.server.core.util.RestTemplateUtils;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.DeserializationFeature;
@@ -40,7 +43,7 @@
 import static au.org.aodn.ogcapi.server.core.util.GeoserverUtils.*;
 
 @Slf4j
-public class WfsServer {
+public class WfsServer implements Server {
     // Cannot use singleton bean as it impacted other dependency
     protected final XmlMapper xmlMapper;
     protected RestTemplateUtils restTemplateUtils;
@@ -79,7 +82,69 @@ public WfsServer(Search search,
         this.pretendUserEntity = entity;
         this.wfsDefaultParam = wfsDefaultParam;
     }
+    /**
+     * Build CQL filter for temporal and spatial constraints
+     */
+    public String buildCqlFilter(String uuid, WfsFeatureRequest featureRequest) {
+
+        WfsFields wfsFieldModel = self.getDownloadableFields(
+                uuid,
+                featureRequest
+        );
+        log.debug("WFSFieldModel by wfs typename: {}", wfsFieldModel);
+
+        // Validate start and end dates
+        final String startDate = DatetimeUtils.validateAndFormatDate(featureRequest.getStartDateTime(), true);
+        final String endDate = DatetimeUtils.validateAndFormatDate(featureRequest.getEndDateTime(), false);
+
+        StringBuilder cqlFilter = new StringBuilder();
+
+        if (wfsFieldModel == null || wfsFieldModel.getFields() == null) {
+            return cqlFilter.toString();
+        }
+
+        List<WfsField> fields = wfsFieldModel.getFields();
+
+        // Possible to have multiple days, better to consider all
+        List<WfsField> temporalField = fields.stream()
+                .filter(field -> "dateTime".equals(field.getType()) || "date".equals(field.getType()))
+                .toList();
 
+        // Add temporal filter only if both dates are specified
+        if (!temporalField.isEmpty() && startDate != null && !startDate.isEmpty() && endDate != null && !endDate.isEmpty()) {
+            List<String> cqls = new ArrayList<>();
+            temporalField.forEach(temp ->
+                    cqls.add(String.format("(%s DURING %sT00:00:00Z/%sT23:59:59Z)", temp.getName(), startDate, endDate))
+            );
+            cqlFilter.append("(").append(String.join(" OR ", cqls)).append(")");
+        }
+
+        // Find geometry field
+        Optional<WfsField> geometryField = fields.stream()
+                .filter(field -> "geometrypropertytype".equalsIgnoreCase(field.getType()))
+                .findFirst();
+
+        // Add spatial filter
+        if (geometryField.isPresent() && featureRequest.getMultiPolygon() != null) {
+            String fieldName = geometryField.get().getName();
+
+            String wkt = GeometryUtils.convertToWkt(featureRequest.getMultiPolygon());
+
+            if ((wkt != null) && !cqlFilter.isEmpty()) {
+                cqlFilter.append(" AND ");
+            }
+
+            if (wkt != null) {
+                cqlFilter.append("INTERSECTS(")
+                        .append(fieldName)
+                        .append(",")
+                        .append(wkt)
+                        .append(")");
+            }
+        }
+
+        return cqlFilter.toString();
+    }
     /**
      * Build WFS GetFeature URL
      */
@@ -203,15 +268,15 @@ protected String createFeatureValueQueryUrl(String url, FeatureRequest request)
                 param.put("TYPENAME", request.getLayerName());
                 param.put("outputFormat", "application/json");
 
-                if (request.getProperties() != null && !request.getProperties().contains(FeatureRequest.PropertyName.wildcard)) {
+                if (request.getProperties() != null && !request.getProperties().contains("*")) {
                     param.put("propertyName", String.join(
                             ",",
-                            request.getProperties().stream().map(Enum::name).toList())
+                            request.getProperties())
                     );
                     param.put("sortBy", String.join(
                             ",",
                             // Assume always sort by desc
-                            request.getProperties().stream().map(p -> String.format("%s+D", p.name())).toList())
+                            request.getProperties().stream().map(p -> String.format("%s+D", p)).toList())
                     );
                 }
 
@@ -450,7 +515,9 @@ public Optional<String> getFeatureServerUrlByTitleOrQueryParam(String collection
      * @param layerName    - The layer name to match the title
      * @return - The matched wfs server link, or the first available one if no match found
      */
-    public Optional<String> getFeatureServerUrl(String collectionId, String layerName) {
+    public Optional<String>
+
+    getFeatureServerUrl(String collectionId, String layerName) {
         Optional<String> url = getFeatureServerUrlByTitleOrQueryParam(collectionId, layerName);
         if (url.isPresent()) {
             log.debug("Found WFS link by title/query param for collectionId {} with layerName {}: {}", collectionId, layerName, url.get());
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wps/WpsServer.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wps/WpsServer.java
new file mode 100644
index 00000000..90df8d4b
--- /dev/null
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/service/geoserver/wps/WpsServer.java
@@ -0,0 +1,206 @@
+package au.org.aodn.ogcapi.server.core.service.geoserver.wps;
+
+import au.org.aodn.ogcapi.server.core.model.ogc.FeatureRequest;
+import au.org.aodn.ogcapi.server.core.service.geoserver.Server;
+import au.org.aodn.ogcapi.server.core.service.geoserver.wfs.WfsServer;
+import au.org.aodn.ogcapi.server.core.service.geoserver.wms.WmsServer;
+import lombok.extern.slf4j.Slf4j;
+import net.opengis.ows11.CodeType;
+import net.opengis.ows11.Ows11Factory;
+import net.opengis.wps10.*;
+import org.geotools.filter.text.cql2.CQL;
+import org.geotools.wps.WPS;
+import org.geotools.wps.WPSConfiguration;
+import org.geotools.xsd.Encoder;
+import org.opengis.filter.Filter;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+import org.w3c.dom.CDATASection;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+
+@Slf4j
+public class WpsServer implements Server {
+
+    protected final RestTemplate restTemplate;
+    protected final WmsServer wmsServer;
+    protected final WfsServer wfsServer;
+    protected final HttpEntity<?> pretendUserEntity;
+
+    public static class WpsProcessRequest extends FeatureRequest {}
+
+    public WpsServer(WmsServer wmsServer, WfsServer wfsServer, RestTemplate restTemplate, HttpEntity<?> entity) {
+        this.wfsServer = wfsServer;
+        this.wmsServer = wmsServer;
+        this.restTemplate = restTemplate;
+        this.pretendUserEntity = entity;
+    }
+
+    public String getEstimateDownloadSize(String uuid, WpsProcessRequest request) throws Exception {
+        // Get WFS server URL and field model for the given UUID and layer name
+        Optional<String> featureServerUrl = wfsServer.getFeatureServerUrl(uuid, request.getLayerName());
+
+        // Get the wfs fields to build the CQL filter
+        if (featureServerUrl.isPresent()) {
+            WfsServer.WfsFeatureRequest featureRequest = WfsServer.WfsFeatureRequest.builder()
+                    .server(featureServerUrl.get())
+                    .layerName(request.getLayerName())
+                    .datetime(request.getDatetime())
+                    .properties(request.getProperties())
+                    .multiPolygon(request.getMultiPolygon())
+                    .build();
+
+            // Build CQL filter as long string
+            String cqlFilter = wfsServer.buildCqlFilter(uuid, featureRequest);
+
+            // Convert to filter
+            Filter filter = CQL.toFilter(cqlFilter);
+
+            // Finally create the request
+            String xmlRequest = createEstimateDownloadSizeXmlRequest(featureRequest.getLayerName(), filter);
+            HttpEntity<String> entity = new HttpEntity<>(xmlRequest, pretendUserEntity.getHeaders());
+
+            ResponseEntity<String> response = restTemplate.exchange(
+                    featureRequest.getServer().replace("wfs", "wps"),
+                    HttpMethod.POST,
+                    entity,
+                    String.class
+            );
+
+            if(response.getStatusCode().is2xxSuccessful()) {
+                return response.getBody();
+            }
+            else {
+                return "";
+            }
+        }
+        else {
+            throw new UnsupportedOperationException("Missing wfs url in metadata");
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    protected String createEstimateDownloadSizeXmlRequest(String layerName, Filter filter) throws Exception {
+        Wps10Factory wpsFactory = Wps10Factory.eINSTANCE;
+        Ows11Factory owsFactory = Ows11Factory.eINSTANCE;
+
+        // 1. Setup Execute Request for gs:DownloadEstimator
+        ExecuteType execute = wpsFactory.createExecuteType();
+        CodeType processId = owsFactory.createCodeType();
+        processId.setValue("gs:DownloadEstimator");
+        execute.setIdentifier(processId);
+
+        DataInputsType1 inputs = wpsFactory.createDataInputsType1();
+
+        // 2. Add 'layername' Input
+        inputs.getInput().add(createLiteralInput("layername", layerName));
+
+        // 3. Add 'filter' Input node and will deal with content later
+        if (filter != null) {
+            inputs.getInput().add(createComplexInput("filter", "text/xml"));
+        }
+
+        execute.setDataInputs(inputs);
+
+
+        ResponseFormType responseForm = wpsFactory.createResponseFormType();
+
+        CodeType outputId = owsFactory.createCodeType();
+        outputId.setValue("result");
+
+        OutputDefinitionType rawOutput = wpsFactory.createOutputDefinitionType();
+        rawOutput.setIdentifier(outputId);
+        rawOutput.setMimeType("application/json");
+        responseForm.setRawDataOutput(rawOutput);
+
+        execute.setResponseForm(responseForm);
+
+        Encoder encoder = new Encoder(new WPSConfiguration());
+        encoder.setIndenting(true);
+
+        Document doc = encoder.encodeAsDOM(execute, WPS.Execute);
+
+        if (filter != null) {
+            // The reason we need to do this is that the Encoder is so restrict that it do not
+            // allow <!CDATA block, so we are force to transform it back to a Document, then
+            // locate the filter section and add the <!CDATA back.
+            Encoder filterEncoder = new Encoder(new org.geotools.filter.v1_1.OGCConfiguration());
+            String filterXml = filterEncoder.encodeAsString(filter, org.geotools.filter.v1_1.OGC.Filter);
+
+            // 2. Find the specific <wps:Input> that has the <ows:Identifier> "filter"
+            NodeList nodes = doc.getElementsByTagNameNS("*", "Input");
+            for (int i = 0; i < nodes.getLength(); i++) {
+                Element inputElem = (Element) nodes.item(i);
+
+                // Check the identifier value
+                NodeList idList = inputElem.getElementsByTagNameNS("*", "Identifier");
+                if (idList.getLength() > 0 && "filter".equals(idList.item(0).getTextContent())) {
+
+                    // 3. Find the <wps:ComplexData> inside THIS specific input
+                    NodeList complexList = inputElem.getElementsByTagNameNS("*", "ComplexData");
+                    if (complexList.getLength() > 0) {
+                        Element complexData = (Element) complexList.item(0);
+
+                        // 4. Inject the CDATA
+                        CDATASection cdata = doc.createCDATASection(filterXml);
+                        complexData.appendChild(cdata);
+                    }
+                }
+            }
+        }
+
+        // 3. Transform the Document back to a String
+        Transformer transformer = TransformerFactory.newInstance().newTransformer();
+        transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");
+
+        try(ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
+            transformer.transform(new DOMSource(doc), new StreamResult(baos));
+            return baos.toString(StandardCharsets.UTF_8);
+        }
+    }
+
+    protected InputType createLiteralInput(String id, String value) {
+        Wps10Factory wpsFactory = Wps10Factory.eINSTANCE;
+        Ows11Factory owsFactory = Ows11Factory.eINSTANCE;
+
+        InputType input = wpsFactory.createInputType();
+        CodeType identifier = owsFactory.createCodeType();
+        identifier.setValue(id);
+        input.setIdentifier(identifier);
+
+        DataType data = wpsFactory.createDataType();
+        LiteralDataType literalData = wpsFactory.createLiteralDataType();
+        literalData.setValue(value);
+        data.setLiteralData(literalData);
+        input.setData(data);
+        return input;
+    }
+
+    protected InputType createComplexInput(String id, String mimeType) {
+        Wps10Factory wpsFactory = Wps10Factory.eINSTANCE;
+        Ows11Factory owsFactory = Ows11Factory.eINSTANCE;
+
+        InputType input = wpsFactory.createInputType();
+        input.setIdentifier(owsFactory.createCodeType());
+        input.getIdentifier().setValue(id);
+
+        ComplexDataType complex = wpsFactory.createComplexDataType();
+        complex.setMimeType(mimeType);
+
+        DataType data = wpsFactory.createDataType();
+        data.setComplexData(complex);
+        input.setData(data);
+        return input;
+    }
+}
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/core/util/DatetimeUtils.java b/server/src/main/java/au/org/aodn/ogcapi/server/core/util/DatetimeUtils.java
index 8837bd35..7c449e3a 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/core/util/DatetimeUtils.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/core/util/DatetimeUtils.java
@@ -12,7 +12,16 @@ public class DatetimeUtils {
     private DatetimeUtils() {
     }
 
+    public static String formatOGCDateTime(String startDate, String endDate) {
+        if(startDate == null || startDate.trim().isEmpty()) {
+            startDate = "..";
+        }
 
+        if(endDate == null || endDate.trim().isEmpty()) {
+            endDate = "..";
+        }
+        return String.format("%s/%s", startDate, endDate);
+    }
     /**
      * Validate and format date for WFS CQL filter
      * Handles MM-YYYY to YYYY-MM-DD conversion for temporal queries
diff --git a/server/src/main/java/au/org/aodn/ogcapi/server/features/RestServices.java b/server/src/main/java/au/org/aodn/ogcapi/server/features/RestServices.java
index f1d1204e..35242eef 100644
--- a/server/src/main/java/au/org/aodn/ogcapi/server/features/RestServices.java
+++ b/server/src/main/java/au/org/aodn/ogcapi/server/features/RestServices.java
@@ -133,8 +133,8 @@ public ResponseEntity<?> getWfsFieldValue(String collectionId, FeatureRequest re
                     .map(WfsField::getName)
                     .toList();
 
-            for (FeatureRequest.PropertyName name : wfsFeatureRequest.getProperties()) {
-                if (extractedName.contains(name.name())) {
+            for (String name : wfsFeatureRequest.getProperties()) {
+                if (extractedName.contains(name)) {
                     // TODO: If missing then may need map
                     log.info("Field {} need map", name);
                     //
diff --git a/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataServiceTest.java b/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataServiceTest.java
index fa40191c..bf089278 100644
--- a/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataServiceTest.java
+++ b/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wfs/DownloadWfsDataServiceTest.java
@@ -60,6 +60,8 @@ public void setUp() {
         Search search = Mockito.mock(Search.class);
 
         wfsServer = Mockito.spy(new WfsServer(search, restTemplate, restTemplateUtils, pretendUserEntity, wfsDefaultParam));
+        wfsServer.self = wfsServer;
+
         wmsServer = Mockito.spy(new WmsServer(search, wfsServer, pretendUserEntity));
 
         downloadWfsDataService = new DownloadWfsDataService(
diff --git a/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wps/WpsServerTest.java b/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wps/WpsServerTest.java
new file mode 100644
index 00000000..900bd17c
--- /dev/null
+++ b/server/src/test/java/au/org/aodn/ogcapi/server/core/service/geoserver/wps/WpsServerTest.java
@@ -0,0 +1,190 @@
+package au.org.aodn.ogcapi.server.core.service.geoserver.wps;
+
+import au.org.aodn.ogcapi.server.core.service.geoserver.wfs.WfsServer;
+import au.org.aodn.ogcapi.server.core.service.geoserver.wms.WmsServer;
+import org.geotools.factory.CommonFactoryFinder;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.opengis.filter.Filter;
+import org.opengis.filter.FilterFactory2;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+import org.xmlunit.builder.DiffBuilder;
+import org.xmlunit.diff.Diff;
+
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class WpsServerTest {
+
+    protected Logger log = LoggerFactory.getLogger(WpsServerTest.class);
+
+    @Mock
+    protected WmsServer wmsServer;
+
+    @Mock
+    protected WfsServer wfsServer;
+
+    @Mock
+    protected RestTemplate restTemplate;
+
+    protected HttpEntity<?> entity = HttpEntity.EMPTY;
+    protected WpsServer wpsServer;
+
+    @BeforeEach
+    void setUp() {
+        wpsServer = new WpsServer(wmsServer, wfsServer, restTemplate, entity);
+    }
+
+    @Test
+    void testCreateEstimateDownloadSizeXmlRequest() throws Exception {
+        // 1. Create a Filter for the test (state = 'TAS')
+        FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
+        Filter filter = ff.equal(ff.property("state"), ff.literal("TAS"), true);
+
+        String layerName = "aodn:my_layer";
+
+        // 2. Generate the XML
+        String resultXml = wpsServer.createEstimateDownloadSizeXmlRequest(layerName, filter);
+
+        // 4. Assertions
+        assertNotNull(resultXml);
+
+        // Verify Identifier for the process
+        assertTrue(resultXml.contains("<ows:Identifier>gs:DownloadEstimator</ows:Identifier>"),
+                "Missing process identifier");
+
+        // Verify LayerName input
+        assertTrue(resultXml.contains("<ows:Identifier>layername</ows:Identifier>"),
+                "Missing layername identifier");
+        assertTrue(resultXml.contains("<wps:LiteralData>aodn:my_layer</wps:LiteralData>"),
+                "Missing layername value");
+
+        // Verify Filter input and CDATA wrapping
+        assertTrue(resultXml.contains("<ows:Identifier>filter</ows:Identifier>"),
+                "Missing filter identifier");
+
+        // Check for CDATA and specific filter content
+        assertTrue(resultXml.contains("<![CDATA["), "Output should contain CDATA section");
+        assertTrue(resultXml.contains("ogc:PropertyIsEqualTo"), "CDATA should contain encoded filter");
+        assertTrue(resultXml.contains("TAS"), "CDATA should contain filter literal value");
+    }
+
+    @Test
+    void getEstimateDownloadSize_success_returnsBody() throws Exception {
+        String uuid = "test-uuid";
+        String layerName = "test:layer";
+        String wfsUrl = "http://example.com/geoserver/wfs";
+        AtomicReference<String> xml = new AtomicReference<>();
+
+        WpsServer.WpsProcessRequest request = new WpsServer.WpsProcessRequest();
+        request.setLayerName(layerName);
+
+        when(wfsServer.getFeatureServerUrl(uuid, layerName)).thenReturn(Optional.of(wfsUrl));
+        when(wfsServer.buildCqlFilter(eq(uuid), any())).thenReturn("state = 'TAS'");
+
+        String mockResponseBody = "{\"estimate\": \"12345 bytes\"}";
+
+        when(restTemplate.exchange(
+                eq("http://example.com/geoserver/wps"),
+                eq(HttpMethod.POST),
+                argThat(e -> {
+                    xml.set(e.getBody().toString());
+                    return e.getBody().toString().contains("gs:DownloadEstimator") &&
+                                e.getBody().toString().contains("filter");
+                }),
+                eq(String.class)
+        )).thenReturn(new ResponseEntity<>(mockResponseBody, HttpStatus.OK));
+
+        String result = wpsServer.getEstimateDownloadSize(uuid, request);
+
+        Diff diff = DiffBuilder
+                .compare(
+                        """
+                        <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+                        <wps:Execute
+                            xmlns:wps="http://www.opengis.net/wps/1.0.0"
+                            xmlns:ows="http://www.opengis.net/ows/1.1"
+                            xmlns:xlink="http://www.w3.org/1999/xlink"
+                            xmlns:xs="http://www.w3.org/2001/XMLSchema" service="WPS" version="1.0.0">
+                            <ows:Identifier>gs:DownloadEstimator</ows:Identifier>
+                            <wps:DataInputs>
+                                <wps:Input>
+                                    <ows:Identifier>layername</ows:Identifier>
+                                    <wps:Data>
+                                        <wps:LiteralData>test:layer</wps:LiteralData>
+                                    </wps:Data>
+                                </wps:Input>
+                                <wps:Input>
+                                    <ows:Identifier>filter</ows:Identifier>
+                                    <wps:Data>
+                                        <wps:ComplexData mimeType="text/xml"><![CDATA[<?xml version="1.0" encoding="UTF-8"?><ogc:Filter xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc"><ogc:PropertyIsEqualTo matchCase="true"><ogc:PropertyName>state</ogc:PropertyName><ogc:Literal>TAS</ogc:Literal></ogc:PropertyIsEqualTo></ogc:Filter>]]></wps:ComplexData>
+                                    </wps:Data>
+                                </wps:Input>
+                            </wps:DataInputs>
+                            <wps:ResponseForm>
+                                <wps:RawDataOutput mimeType="application/json">
+                                    <ows:Identifier>result</ows:Identifier>
+                                </wps:RawDataOutput>
+                            </wps:ResponseForm>
+                        </wps:Execute>
+                        """
+                )
+                .withTest(xml.get())
+                .ignoreWhitespace()
+                .normalizeWhitespace()
+                .ignoreComments()
+                .checkForSimilar()
+                .build();
+
+        assertEquals(mockResponseBody, result);
+        assertFalse(diff.hasDifferences(), "XML body match");
+        verify(restTemplate).exchange(eq("http://example.com/geoserver/wps"), eq(HttpMethod.POST), any(), eq(String.class));
+    }
+
+    @Test
+    void getEstimateDownloadSize_noWfsUrl_throwsException() {
+        String uuid = "test-uuid";
+        WpsServer.WpsProcessRequest request = new WpsServer.WpsProcessRequest();
+        request.setLayerName("test:layer");
+
+        when(wfsServer.getFeatureServerUrl(anyString(), anyString())).thenReturn(Optional.empty());
+
+        assertThrows(UnsupportedOperationException.class,
+                () -> wpsServer.getEstimateDownloadSize(uuid, request));
+    }
+
+    @Test
+    void getEstimateDownloadSize_non2xx_returnsEmpty() throws Exception {
+        String uuid = "test-uuid";
+        String layerName = "test:layer";
+        String wfsUrl = "http://example.com/geoserver/wfs";
+
+        WpsServer.WpsProcessRequest request = new WpsServer.WpsProcessRequest();
+        request.setLayerName(layerName);
+
+        when(wfsServer.getFeatureServerUrl(uuid, layerName)).thenReturn(Optional.of(wfsUrl));
+        when(wfsServer.buildCqlFilter(eq(uuid), any())).thenReturn("state = 'TAS'");
+
+        when(restTemplate.exchange(anyString(), eq(HttpMethod.POST), any(), eq(String.class)))
+                .thenReturn(new ResponseEntity<>("error", HttpStatus.BAD_REQUEST));
+
+        String result = wpsServer.getEstimateDownloadSize(uuid, request);
+
+        assertEquals("", result);
+    }
+}
diff --git a/server/src/test/java/au/org/aodn/ogcapi/server/features/RestServicesTest.java b/server/src/test/java/au/org/aodn/ogcapi/server/features/RestServicesTest.java
index e07a4713..5afb0fd8 100644
--- a/server/src/test/java/au/org/aodn/ogcapi/server/features/RestServicesTest.java
+++ b/server/src/test/java/au/org/aodn/ogcapi/server/features/RestServicesTest.java
@@ -126,7 +126,7 @@ public void testGetWfsTimeFieldWorks() {
         ResponseEntity<?> response = restServices.getWfsFieldValue(
                 "any-works",
                 FeatureRequest.builder()
-                        .properties(List.of(FeatureRequest.PropertyName.time))
+                        .properties(List.of("time"))
                         .build()
         );
         assertInstanceOf(Map.class, response.getBody());
diff --git a/server/src/test/java/au/org/aodn/ogcapi/server/service/ElasticSearchTest.java b/server/src/test/java/au/org/aodn/ogcapi/server/service/ElasticSearchTest.java
index 96a51769..624182f5 100644
--- a/server/src/test/java/au/org/aodn/ogcapi/server/service/ElasticSearchTest.java
+++ b/server/src/test/java/au/org/aodn/ogcapi/server/service/ElasticSearchTest.java
@@ -51,7 +51,7 @@ public void searchFeatureSummaryTest() throws IOException {
 
         // Arrange
         String collectionId = "test-collection";
-        List<FeatureRequest.PropertyName> properties = List.of(FeatureRequest.PropertyName.wildcard);
+        List<String> properties = List.of("*");
         String filter = null;
 
         SearchResponse<EsFeatureCollectionModel> mockResponse = mock(SearchResponse.class);