Tailwind Traders Backend
The back-end services of the Tailwind Traders sample retail application: cart, coupon, login, product, profile, stock and other services in C#, JavaScript, Java and Go behind API gateways. Published by Microsoft as a sample.
Business rules, traced to source lines.
These 8 rules are a sample of the 1,635 CoreStory V3 extracted from Tailwind Traders Backend. Each one links to the exact lines on GitHub at commit 03852ac. The statement is CoreStory V3’s wording; the code excerpt is the source it cites.
A login request is rejected with BadRequest when the username is null, empty, or whitespace, or the password is null, empty, or whitespace, or the grant type is not exactly "password".
- password — required grant type value
The token must pass jwt.verify using config.SecurityKey and the decoded payload's iss claim must equal config.Issuer; otherwise the request is rejected with HTTP status 401 and a JSON body of success false and message 'Token is not valid'. On success, the decoded payload is assigned to req.decoded and next() is called.
- 401 — HTTP status returned when the token is invalid
- false — success flag in the invalidity rejection body
- Token is not valid — error message returned when the token is invalid
Also cited: L2
When refreshing an access token with a token not present in the registered refresh token list, the token must be readable and must contain a Name claim; otherwise an exception "Refresh token is not valid." is thrown.
- Refresh token is not valid. — exception message when token cannot yield a user name
After fetching product details, the controller calls the Stock API for the same id; on success it sets product.StockUnits to the integer productStock value parsed from the response JSON; on HttpRequestException it logs the error and sets product.StockUnits to 0.
- 0 — fallback stock units when the Stock API call fails
After a successful classification, the controller queries the Products API GetByTag endpoint with the result Label. If the response StatusCode is 404 NotFound, the endpoint returns OK with an empty ClassifiedProductItem sequence. Otherwise it ensures success and returns the deserialized suggested products.
- 404 — status code treated as no products for the tag
If a customer already exists with the given email (looked up by email or name), Registration returns false without inserting a new customer, indicating the registration is rejected.
Updating a product quantity requires both 'qty' and 'id' in the request body; if either is falsy, respond with HTTP status 400 and message "'id' and/or 'qty' missing"; otherwise update the quantity and respond with HTTP status 201 and message "Product qty updated".
- 400 — HTTP status code for missing required fields
- 201 — HTTP status code for successful quantity update
- 'id' and/or 'qty' missing — error message when id or qty is missing
- Product qty updated — success message for quantity update
Retrieving related products requires at least one of query parameter 'type' or the user header 'x-tt-name'; if both are absent, respond with HTTP status 400 and message "'user' or 'productType' missing"; otherwise fetch and return related items.
- 400 — HTTP status code when neither type nor user is present
- 'user' or 'productType' missing — error message when both type and user are missing
What the application does
13 capabilities identified, grouping 276 of the 279 distinct features extracted. These are descriptions, not the cited rules above.
Kubernetes & Container Deployment
Defining and deploying containerized workloads to Kubernetes, including Helm values, services, ingress, resources, probes, and scheduling.
- Application Deployment: Deploys application images and pictures to the target environment.
- Application Deployment Configuration: Users specify the container image, replica count, and application identity used to deploy the application.
- Application Specification: Allows users to declare application details such as name, type, protocol, and ports for a deployment target.
- Chart Deployment: Deploys and identifies an application via a chart artifact and its type.
- Chart Metadata Display: Surfaces chart-related metadata such as chart, heritage, and release information to the client through labels and container data.
- Chart and Release Management: Supports specifying chart and release information for deployments, including heritage and target port settings.
- Container Build: Builds a container from base and final build stages, producing an image tagged with the runtime identity.
- Container Build and Publish: Builds and publishes a Docker container for a code project, including runtime and SDK image/tag configuration.
- Container Configuration: Enables users to define and manage container specifications including metadata, labels, ports, and selectors.
- Container Deployment: Deploy applications as selectable containers with metadata, labels, and exposed ports.
- Container Health Probes: Configures liveness and readiness checks that determine when a container is healthy and ready to serve traffic.
- Container Image Build: Building a code container image from a configured base and publishing the resulting image.
- Container Image Build and Push: Builds and pushes Docker container images, including registry authentication.
- Container Image Configuration: Users specify the container repository, tag, and image pull policy that determine which image runs.
- Container Image Pulling: Users configure how container images are fetched and pulled from the registry.
- Container Image Registry Publish: Builds, tags, and pushes container images to a specified Azure Container Registry using provided credentials.
- Container Resource Allocation: Users set CPU and memory requests and limits for the deployed containers.
- Container Resource Limits and Requests: Specifies CPU and memory resource requests and limits for containers.
- Container Resource Management: Specifies CPU and memory requests and limits for containers.
- Container Resource and Health Probe Configuration: Configure container resource requests/limits and liveness/readiness health probes with timing parameters.
- Container Specification: Customizes how the application container is run, including its image, exposed ports, environment variables, and resource requests.
- Environment Configuration: Injecting environment variables into containers to configure runtime behavior.
- Environment and ConfigMap Configuration: Users supply environment variables and ConfigMap data to configure the running application.
- Environment and ConfigMap Injection: Injects environment variables and configmap-backed configuration into workloads.
- HTTP Request Routing: Exposes an HTTP router that dispatches incoming requests to their handlers.
- Health Probe Configuration: Users configure liveness and readiness probes with timing parameters to monitor application health.
- Health Probes: Configuring liveness and readiness probes so the platform can monitor and manage container health.
- Health Probing: Users configure liveness and readiness probes so the platform can observe container health and gate traffic.
- Helm Chart Deployment Configuration: A Helm values manifest configures Kubernetes deployment parameters such as replicas, container image, resources, probes, node selection, and service exposure for the application.
- Helm Chart Values Configuration: Users supply deployment parameters such as replica counts, container images, resource limits, probes, scheduling constraints, and service settings through chart values.
- Helm Command Generation: Generates Helm commands for deploying charts to an AKS cluster with configurable release parameters.
- Helm Values Overrides: Provides a values structure for user-supplied configuration overrides of the deployment.
- Horizontal Pod Autoscaling: The system exposes a HorizontalPodAutoscaler resource that automatically scales a target workload between a minimum and maximum replica count based on resource utilization metrics.
- Host-Based Routing: Routes incoming requests based on configured hostnames.
- Identity and Credentials: Users assign workload names, service accounts, and image pull secrets to control identity and registry access.
- Image Publish: Publishes the built SDK container image under an SDK tag for downstream consumption.
- Image Pull Configuration: Specifying container images, pull policies, and image pull secrets for retrieving workload images.
- Image Pull Credentials: Provides registry secrets used to authenticate pulling the container image from private registries.
- Ingress HTTP Routing: Defines HTTP routing rules that map request paths to backend services for incoming traffic.
- Ingress Metadata Management: Supports naming, labeling, and annotating ingress resources for identification and organization.
- Ingress Resource Provisioning: Provisioning of ingress resources with their cluster identity, name, and ingress class parameters.
- Ingress TLS Certificate Provisioning: Automatically provisions TLS certificates for an application's ingress using a specified certificate issuer and secret, so the app is served over HTTPS under its server name.
- Ingress TLS Configuration: Configuration of TLS/SSL settings for ingress resources, including certificate files, TLS secrets, and environment-specific SSL support.
- Kubernetes Deployment Configuration: Defines Kubernetes workload deployment settings such as replica count, container image, node selection, and tolerations.
- Kubernetes Deployment Manifest: Defines a Kubernetes Deployment resource describing the desired pod template, replica count, and metadata for running an application workload.
- Kubernetes Helm Deployment Setup: Installs Helm and configures the deployment environment for Kubernetes releases.
- Kubernetes Workload Configuration: Users declare container images, replicas, environment variables, and tolerations to define how a workload is deployed on a Kubernetes cluster.
- Node OS Scheduling: Targets workloads to nodes by operating system label.
- Node Scheduling Targeting: Users direct workload placement using node selectors and OS labels.
- Pod Scheduling and Placement: Controls where pods run across the cluster via node selectors, affinity rules, and tolerations.
- Port Exposure Configuration: Defines the network ports and protocols a workload exposes and the target ports they map to, enabling external connectivity.
- Port Mapping: Expose and target container ports so the deployed app is reachable at named protocols and ports.
- Resource Limits Configuration: Declaring compute resource requests and limits for containers.
- Resource and Scheduling Configuration: Users set CPU resources, resource limits and requests, node selection, and tolerations for workload placement.
- SDK Version and Image Versioning: Tracking SDK and runtime version tags and their associated images for the code container.
- Service Account Binding: Associates the workload with a Kubernetes service account identity for API access.
- Service Deployment Configuration: Definition of the backend services container and its service composition.
- Service Deployment Specification: Declares and configures a deployable service or workload via a code container with metadata, labels, a selector, and a rendered spec.
- Service Discovery Targeting: Users attach labels and selector match rules so services can discover and target the deployed containers.
- Service Exposure Configuration: Users define the service type and port to expose the application to network clients.
- Service Metadata Inspection: Surfaces service labeling and metadata for identification and selection.
- Service Port Discovery: Exposes service network endpoints and port information to users or other systems.
- Service Selector Matching: Enables selection of services by matching selectors against service specifications.
- Service and Environment Definition: Configure exposed services, environment variables, and configmap-backed configuration values.
- Service and Networking Configuration: Configures Kubernetes service exposure with port, type, and application name settings.
- TLS Termination: Configures TLS settings, including named secrets, for secure ingress traffic.
- Workload Scheduling: Users control where pods are scheduled through node selection, affinity rules, and tolerations.
Product Catalog
Browsing, listing, searching, and displaying products, brands, types, features, tags, and popular/recommended items.
- Brand Listing: Exposes an endpoint to retrieve all product brands for clients.
- DTO Mapping: Transforms domain product/brand data into DTOs returned to API consumers.
- Popular Products: Surfaces popular products to users.
- Popular Products Display: Surfaces best-selling or frequently purchased products to the user, including product naming and chart-based product comparisons.
- Product API: Exposes product-related operations as a user-facing API endpoint.
- Product Brand Browsing: Retrieves product brand information, exposing each brand with an identifier and display name for consumers of the product API.
- Product Brand and Type Lookup: Users can retrieve available product brands and types for browsing and filtering.
- Product Browsing: Retrieves products and popular products from configured product API endpoints.
- Product Catalog: Exposes product data including identity, branding, pricing, imagery, and categorization for display to users.
- Product Catalog Browsing: Displays products and their details to users.
- Product Catalog Data Model: Defines the persisted entities representing the product catalog — products, brands, types, features, and tags — through the database context.
- Product Catalog Display: Exposes product information such as name, brand, image, price, type, features, and stock availability for display to users.
- Product Data Access: Provides persistence access to product data backing the brand queries.
- Product Detail Lookup: Clients can fetch detailed information for an individual product.
- Product Details Display: Provides product detail information including identity, title, and descriptive attributes to a user-facing client.
- Product Features: Exposes descriptive product feature attributes (title, description, product association) that users can view on products.
- Product Item Mapping: Maps product entities to product item representations for the product API.
- Product Listing: Provides a listing of available products that users or other systems can retrieve.
- Product Listing Retrieval: Clients can retrieve the list of available products exposed by the Products controller.
- Product Recommendations: Users are shown recommended and popular products.
- Product Tag Search: Users can find products by tag.
- Product Type Catalog: Exposes product type information, each with an identifier and name, so consumers can list and identify the product categories offered.
- Product Type Listing: Expose an API capability to retrieve or serve the catalog of product types to consumers.
- Product Type Management: Named product types with identity, exposed as data structures for clients of the mobile BFF.
- Recommended Products: Users receive product recommendations, including popular products.
- Related Product Suggestions: Suggests related products to the user, typically alongside their cart.
- Stock Availability: Capability for checking product stock via the stock API.
- Stock Checking: Users can check product stock availability via the stock API.
- Stock Decrease: Allows a user to reduce the stock quantity for a product through the stock controller.
- Stock Item Management: Create and maintain stock items identified by product, partition, and id with an associated stock count.
- Stock Item Persistence: Create or update stock items in the repository.
- Stock Item Retrieval: Fetch a single stock item by its identifier or by product identifier from the backing store.
- Stock Item Seeding: Seeds an initial default set of stock items into the repository, skipping items that are already present.
- Stock Lookup: Provides product stock availability information.
- Stock Product Management: Allows users to view and update a stock product's identifier and product stock level.
Service Hosting & Bootstrap
Bootstrapping and hosting the various web services and BFFs, including startup, DI registration, routing, and configuration composition.
- API Documentation: Serves interactive API documentation so consumers can discover and try the available endpoints.
- API Endpoint Discovery: Supplies the base URLs for the various backend APIs the client consumes.
- ASP.NET Core Web Hosting: Configure and host an ASP.NET Core web application using the specified hosting model.
- Additional Config Loading: Reads and applies additional configuration and environment setup with pre/post rc customization.
- Application Configuration: Provides deployment configuration values to the application.
- Application Startup: Bootstraps and launches the profile API web host for the service.
- BFF Application Hosting & Bootstrap: Application startup capability that configures and launches the BFF host using its runtime configuration.
- BFF Service Registration: Composition-root capability that wires up the BFF's HTTP clients and dependency-injected services so requests can be routed to backend APIs.
- Configuration Management: Centralized application configuration supplying API endpoints, identity/security settings, and deployment metadata to the system.
- HTTP Request Routing: Exposes an HTTP router that dispatches incoming requests to their handlers.
- HTTP Response Logging: Wraps the HTTP response writer to capture the status code and log details of each response written.
- Health Check: Exposes a health-check capability so operators or monitoring systems can verify the service is running.
- Health Check Endpoint: Exposes an application health-check capability that other systems can probe to verify the service is running.
- Health Checks: Registers health-check endpoints that let operators and load balancers observe whether the service is alive and ready.
- Home Page Redirect: Directs requests for the site root to another page via the home controller's redirect action.
- Hosting and Logging Configuration: Application host settings and allowed hosts configuration supporting the hosting and logging stack.
- Logging Configuration: Controls the application's logging verbosity through a configurable log level setting.
- Login Service Health Monitoring: Exposes health check endpoints for the Login API so operators and orchestration systems can observe whether the service is running healthy.
- Mobile API Gateway: Entry point that exposes backend services to mobile clients.
- Mobile Storefront: Serves the mobile customer interface.
- Module Registration: Allows application modules to be discovered and wired into the service container so their capabilities become available at runtime.
- Ping Endpoint: A health-check style endpoint that responds to ping requests to confirm the service is reachable.
- Product API Hosting: Bootstraps and hosts the Product API web service that clients call over HTTP.
- Product API Service Registration: Registration of the Products API's application services, data context, and health checks into the ASP.NET Core dependency injection container so the API can start and expose its endpoints.
- Security Configuration: Configures the application's security behavior by letting a security configurer adapter apply customizations through its configuration entry point.
- Service Health Check: Exposes a health endpoint that reports service liveness by probing backing data stores such as Cosmos DB.
- Swagger API Documentation: Provides OpenAPI/Swagger documentation for the WebBff service, including authentication security requirements.
- Web API Gateway: Entry point that exposes backend services to web clients.
- Web BFF Hosting and Startup: Bootstraps and runs the Tailwind.Traders.WebBff backend-for-frontend web host from the application entry point.
- Web Host Startup: Bootstraps and launches the application's web host so the Bff service begins serving requests.
- Web Storefront: Serves the customer-facing web storefront interface.
Azure Cloud Infrastructure Provisioning
Provisioning Azure resources such as AKS clusters, container registries, Cosmos DB, storage, App Insights, Log Analytics, and function apps.
- AKS Cluster Provisioning: Provisions an Azure Kubernetes Service cluster with a specified version.
- AKS Host Provisioning: Resolves or provisions an Azure Kubernetes Service host by resource group and name for use as the test target.
- Application Configuration: Provides deployment configuration values to the application.
- Application Hosting: Azure Web site resource hosting the application workload.
- Application Hosting and Storage: Deploys an App Service site and a storage account for hosted application workloads and data.
- Application Insights Integration: Configuration of Application Insights telemetry via instrumentation key and logging level settings.
- Application Insights Provisioning: Provisions an Application Insights component for telemetry.
- Application Insights Telemetry: Configures telemetry instrumentation key for application monitoring.
- Application Insights Telemetry Configuration: Configures Application Insights telemetry by supplying the instrumentation key and allowed hosts so operational monitoring is enabled for the deployed application.
- Application Runtime Configuration: Environment-driven configuration supplies runtime settings including ASP.NET Core environment, application name, image path, and security keys to the application.
- Application Telemetry: Application Insights integration that collects and surfaces telemetry for the deployed application.
- Azure Cloud Authentication and Setup: Authenticates to Azure, selects the subscription, and obtains credentials for deployment.
- Azure Infrastructure Deployment: Deploys a full Azure environment encompassing container registry, managed Kubernetes cluster, Cosmos DB accounts, monitoring, and storage resources.
- Cloud Storage Provisioning: Azure Storage account resource provided for the application to persist data.
- Container Registry Provisioning: Provisions an Azure Container Registry instance for hosting images.
- Cosmos DB Configuration: Configuration of the Cosmos DB connection via a key.
- Cosmos DB Connection: Configuration of a Cosmos DB data store connection including host and security key credentials.
- Cosmos DB Connectivity: Database connection configuration for Cosmos DB via host, key, and database name settings.
- Cosmos DB Database Provisioning: Provisions Cosmos DB accounts backing the shopping and coupons data stores.
- Cosmos DB Provisioning: Provisions Cosmos DB databases for shopping and coupons data.
- Document Database Provisioning: Cosmos DB accounts provisioned to back the shopping and coupons data stores.
- Function App Provisioning: Provisions a function app for serverless workloads.
- Log Analytics Workspace Provisioning: Provisions an OMS/Log Analytics workspace for monitoring.
- Monitoring and Observability Setup: Sets up Application Insights and a Log Analytics workspace with its management solutions.
- Secret Creation: Create and validate a secret against an Azure resource, given credentials and target identifiers.
- Service Principal Configuration: Supplies service principal credentials used for deployment authentication.
- Storage Account Provisioning: Provisions a storage account for the deployment.
- Storage Name Validation: Validates a storage name within a given resource group against naming constraints.
- VM Admin Credential Configuration: Provides administrator usernames and keys/passwords for Linux and Windows nodes.
User Registration and Profiles
Registration of new customers/users and storage, retrieval, and management of user and customer profile data.
- Customer Lookup: Retrieves an existing customer by email address or name.
- Customer Management: Capability to represent and manage customer registration data including identity, contact details, and enrollment status.
- Customer Registration: Enrolls a new customer by persisting their details into the rewards customer store.
- Profile Browsing: Retrieves individual and list-based user profile information through the profiles controller for client consumption.
- Profile Data Import: Ingests user profile records (name, email, phone, address, images) from CSV files into the system.
- Profile Data Seeding: Populates the profile database with initial user profile data from a CSV source during startup.
- Profile Management: Allows users to view and manage their profile through a profile API.
- Profile NavBar Retrieval: Clients can retrieve the navigation bar profile data used to render profile-related navigation in the UI.
- Profile Navigation: Supplies navbar navigation data for profiles to the mobile client.
- Profile Persistence: Provides storage and retrieval of profile records through an Entity Framework context exposed via the API infrastructure layer.
- Profile Retrieval: Clients can retrieve user profile data, both a single profile and a collection of profiles, via the Web BFF controller that exposes these endpoints.
- Profile Viewing: Retrieves user profile information from a configured profile API endpoint.
- Rewards: Offers rewards and rewards registration to users.
- Tailwind Traders Mobile BFF Registration: The Tailwind Traders Mobile BFF service registers users into the system if they do not already exist.
- Tailwind Traders Web BFF Services: A service that registers users if they do not already exist.
- User Profile: Provides user profile viewing and management.
- User Profile Creation: Accepts user profile details (name, email, phone, address) to create a user profile via the map-user-profile operation.
- User Profile Display: Exposes a user profile containing identity and contact details along with small and medium avatar images for display.
- User Profile Retrieval: Provides access to a user's profile information including name, contact details, identifiers, and profile image URLs.
- User Profile View: Exposes a user profile carrying identity, contact, and avatar details that clients can read or render.
- User Profile Viewing: Users can retrieve individual and multiple user profiles.
- User Registration: Enables new users to register accounts.
- User Registration Service: A user-facing service that handles user registration operations.
Image Classification
Uploading images and classifying them via ML/ML.NET/TensorFlow models, including prediction, labels, and model configuration.
- API Service Configuration: The application startup composes and applies the service and content-root configuration that the image classifier API runs with.
- Classified Product Listing: Presents classified products with product details such as name, image, price, and status.
- Classified Product Retrieval: Provides classified product details including name, id, price, and image URL for display.
- Classifier Invocation: The ML net classifier action can be triggered to classify via the classifier client.
- Image Classification: Classifies images via a configured classifier endpoint, optionally using an ML.NET classifier.
- Image Classification Configuration: Configurable image settings for classifying images with a trained ML.NET model, including dimensions, channel layout, and normalization mean.
- Image Classification Labels: Retrieves the best-matching label for a classification result and exposes the set of available labels and the model asset path.
- Image Classification Prediction: Produces a predicted label and confidence probability for an input image, observed through the prediction result structure.
- Image Data View Loading: Loads image files from a configured folder into an in-memory data view for training or evaluation.
- Image Name Validation: Validates provided image names against naming constraints and returns a validity result.
- Image Path Validation: Validates image file paths and locations to confirm they are acceptable.
- Image Submission: Users can submit images for classification.
- Image Upload and Classification: Users can upload images for classification.
- ML Model Initialization: Initializes the ML context and loads the trained model from its configured location so it can serve predictions.
- Machine Learning Classification: System exposes an ML-based classification action via the DoMlNetClassifierAction endpoint.
- Product Classification: Classifies products into a structured result carrying identity, display name, image, and price for presentation to users.
- Product Image Classification: Classifies product images via an image classifier service.
- Product Image Upload: Clients can post an image associated with a product through the controller.
- TensorFlow Model Configuration: Provides settings to configure a TensorFlow model's input and output tensor names and related model options.
- Web Host Startup: Bootstraps and launches the application's web host so the Bff service begins serving requests.
User Authentication
Login, sign-in, token issuance/refresh, password grant, and token validation for user sessions across the system.
- Access Token Refresh: Renews a user's access credentials without requiring re-authentication.
- Authentication Token Exchange: Exposes authentication and token response models carrying access, refresh, and bearer token metadata for clients that authenticate against the WebBff.
- B2C Authentication: Configures Azure AD B2C-based authentication with issuer and authority settings.
- B2C Mode Toggle: A configuration-driven capability that reads whether the storefront should operate in B2C mode and exposes it to the web BFF.
- Basic Authentication: Clients authenticate to the API by presenting HTTP Basic credentials via an authorization header, handled by a dedicated authentication handler.
- Identity Resolution from Token: Recovers the authenticated user's identity from a presented token.
- Login API Service Startup: Bootstraps and configures the Login API service so it can be hosted and serve login requests.
- Login HTTP API: Exposes an HTTP API service that handles login operations for the Tailwind Traders application.
- Outgoing HTTP Authorization: Automatically attaches bearer authentication credentials to outgoing HTTP requests made by the service.
- Outgoing HTTP Request Authorization: Attaches authorization credentials to outgoing HTTP requests via a delegating handler.
- Password Grant Authentication: Clients authenticate by exchanging a username, password, and grant type for an access token.
- Security Token Issuance: Issues security tokens using configured issuers and security keys.
- Security Token Validation: Validates security tokens using a configured issuer and signing security key.
- Token Issuance: Issues authentication token responses containing access and refresh tokens with their type and expiry for clients to consume.
- Token Refresh: Refreshes an authentication token for a client session via the auth controller.
- Token Request: Supports requesting an authentication token via username, password, and grant type credentials.
- Token Request Authentication: Accepts user credentials with a grant type and models them as a request for token issuance.
- User Authentication: Users can log in and refresh their authentication tokens.
- User Login: Provides user authentication and login capability for the storefront.
- User Sign In: Authenticates a user and issues access and refresh tokens for the session.
CI/CD Pipelines & Build Automation
Continuous integration and deployment pipelines, builds across toolchains, container image publication, and pipeline environment setup.
- Application Build: Compilation of the project across supported platforms and language toolchains, including .NET, Java/Maven, and JavaScript jobs.
- Build Plugin Execution: Supports attaching and executing plugins as part of the project build lifecycle.
- CI Job Execution: Definition and execution of the continuous integration jobs, including their triggers, runner environments, and ordered steps.
- CI Pipeline Execution: Runs the build and deployment pipelines for pull requests, main branch, and nightly schedules.
- CodeQL Security Scanning: Automated static code analysis that checks out the repository, initializes CodeQL, and performs analysis to surface security findings.
- Container Image Build and Push: Builds and pushes Docker container images, including registry authentication.
- Cross-Platform Build: Produces platform-specific build artifacts for Linux and Windows targets.
- Docker Compose Build: Defines a Docker Compose-based build workflow driven by a compose file and source folder.
- Docker Containerization: Build a containerized deployment of the application targeting a selected operating system.
- Docker Service Launch: Launch a project's configured Docker service and open the associated service URL in a browser.
- Load Testing: Executes a configurable load test against a target URI with tunable parallelism, iteration count, and randomized sleep intervals.
- Maven Project Base Directory Detection: Locates the Maven project's base directory during execution so that the wrapper and configuration are resolved correctly.
- Maven Wrapper Launch: Bootstraps and launches the Maven executable for the project via the wrapper jar and launcher.
- Script Deployment: Deploys build scripts and job definitions to the target environment.
- Secrets and Extension Setup: Creates required secrets and installs pipeline extensions to prepare the build environment.
- Solution Deployment: Deploys the full solution environment including its deployable workspaces.
- Workspace Deployment: Provisions a workspace with parameters, variables, resources, and outputs.
Shopping Cart and Coupons
Managing a user's shopping cart and applying/viewing coupons and discounts.
- Add Product to Cart: Allows a user to add a product to their shopping cart.
- Cart Management: Capability for managing a user's shopping cart via the cart API.
- Coupon Access: Exposes coupon data to users via a coupons API.
- Coupon Application: Users can apply coupons backed by the coupon API and its Cosmos DB collection.
- Coupon Detail Display: Surfaces individual coupon attributes such as discount, description, image, title and expiry for presentation.
- Coupon Listing: Exposes coupon information including discounts, validity period, and imagery for display to mobile clients.
- Coupon Management: Exposes coupon browsing and imagery to users.
- Coupon Retrieval: Provides an API capability for clients to fetch available coupons via the coupons controller.
- Coupon Viewing: Fetches coupon data from a configured coupons API endpoint.
- Coupons: Users can view available coupons.
- Remove Item from Cart: Allows a user to delete an item from their shopping cart.
- Shopping Cart: Lets users manage a shopping cart.
- Shopping Cart Management: Add, update, remove, and retrieve items in a user's shopping cart.
- Update Cart Item Quantity: Allows a user to change the quantity of a product in their cart.
- View Cart Contents: Displays the products currently in a user's shopping cart.
Backend Service Integration & Messaging
Client channels, WCF service registration, asynchronous messaging, and authorization for outgoing calls between services.
- API Endpoint Discovery: Supplies the base URLs for the various backend APIs the client consumes.
- Asynchronous Message Delivery: Dispatches messages asynchronously through a message handler on behalf of the BFF infrastructure.
- Asynchronous Message Sending: Allows sending of messages asynchronously through a message handler using the current HTTP context.
- Client Session Lifecycle: Opening, registering against, and closing the user service client connection.
- Outgoing HTTP Authorization: Automatically attaches bearer authentication credentials to outgoing HTTP requests made by the service.
- Outgoing HTTP Request Authorization: Attaches authorization credentials to outgoing HTTP requests via a delegating handler.
- Service Channel Registration: Register and open a WCF service channel to the user service, with endpoint and binding configuration, so a client can invoke the service.
- Service Endpoint Configuration: Resolution of the correct binding, endpoint address, and endpoint setup used to connect to the user service.
- User Service Client Channel: A WCF client channel that connects to and communicates with the user service endpoint.
Data Persistence & Seeding
Database connections, queries, CSV data loading, and seeding initial data across the system's stores.
- CSV Data Import: Loads and parses CSV data into the application via a reusable reader helper.
- CSV Data Loading: Loads tabular data from CSV sources into the system for downstream use.
- Content Tokenization: Reads content from an input file or source and produces tokens as output.
- Database Connection Creation: Establishes a connection to the database using a configured connection string, surfacing any resulting context or error.
- Database Seeding: Bootstraps a database with initial product data by invoking a seed routine against a data context, enabling the application to start with usable content.
- Query Filtering: Capability to build and apply logical filter criteria (left/right operands combined with OR) to queries via filter extension support.
- SQL Query Execution: Execute select and non-select SQL statements against an underlying database connection via a repository abstraction.
- Todo Collection Access: Obtain the todo collection and its database for read/write operations.
Project & Build Configuration
Defining project metadata, build configuration, dependency management, and generated message contracts.
- Collection Type Reference Configuration: Allows specifying collection and dictionary collection types used when generating message contracts.
- Message Contract Generation: Generates message contracts from referenced assemblies with configurable namespace, access level, and type reuse options.
- NuGet Package Dependency Management: Declare and resolve external library dependencies via package references for the project.
- Parameter Validation: Validates the provided configuration parameters before use.
- Project Build Configuration: Define project properties and content grouping so the build system compiles and includes the right assets.
- Project Configuration Management: Define and organize a project's build configuration through items, property groups, and project metadata such as GUID and version.
- Project Model Configuration: Enables definition and loading of a project's metadata and build configuration such as identity, version, packaging, and dependencies.
- Project Relationship Hierarchy: Allows a project to declare its parent and other relationships, forming a hierarchy across projects.
Documentation & Error Reporting
User-facing documentation display and surfacing execution errors with error codes.
- Error Reporting: Surfaces execution errors to the user through error and end handlers with an error code.
- Getting Started Documentation Display: Displays a getting started document to guide users, including external reference links.
What was analyzed
- JSON · 29 files · 5,347 lines
- C# · 137 files · 4,254 lines
- YAML · 106 files · 3,350 lines
- PowerShell · 17 files · 810 lines
- Markdown · 10 files · 761 lines
- JavaScript · 20 files · 574 lines
- Java · 11 files · 377 lines
- MSBuild script · 7 files · 291 lines
- Go · 14 files · 290 lines
- Dockerfile · 17 files · 268 lines
- Text · 14 files · 232 lines
- Other (8 languages) · 31 files · 1,237 lines
Whole repository: 789 files. cloc 2.06 counts 17,791 lines of code in 413 of them (20,029 lines with comments and blanks).
Where this came from
Extracted by CoreStory V3 (build 4470 with two small engine fixes) using DeepSeek-V4.1-Flash from the public repository at commit 03852ac on 2026-11-13. Capability descriptions are from the same run.
- Repository microsoft/TailwindTraders-Backend
- Commit 03852ac338462b661d5837d01ebf0a712e12866c
- Line counts cloc 2.06
- Rule citations Each rule shown was checked: its quote was compared with the repository source at the cited lines at this commit.
Code excerpts are from the upstream repository and remain under its MIT license. CoreStory is not affiliated with or endorsed by Microsoft.
Want this for your own codebase?
Talk to us about mapping the business rules in your repositories.