Navigate Red Hat Developer Hub on your first day
Log in, navigate the Red Hat Developer Hub (RHDH) interface, and personalize your workspace to become productive immediately
Abstract
- 1. Purpose and structure of Red Hat Developer Hub
- 2. Log in to Red Hat Developer Hub
- 3. Find software components to discover assets
- 4. Import and use an existing Software Template for faster development
- 5. Search for relevant content in Technical Documentation (TechDocs)
- 6. Verify API contracts before integrating with backend services
- 7. Find resources and documentation using search
- 8. Get AI-assisted help for your development tasks
- 9. Integrate and customize your daily tools using extensions
- 10. Customize your RHDH interface settings
- 11. Manage starred items for quick access
As a new developer, you will learn how to personalize your experience by customizing settings and starring often used items, enabling you to independently find the software catalog, templates, and documentation you need.
3. Find software components to discover assets
To integrate with existing software, check ownership, or prevent duplicate development, use the Software Catalog in Red Hat Developer Hub (RHDH). You can use this centralized inventory to discover assets without searching through many documentation sources or repositories.
By using the Software Catalog, you can achieve the following outcomes:
- Reuse existing code
- Locate shared libraries and components to prevent duplication of effort.
- Understand dependencies
- Visualize connections between services and API contracts.
- Identify ownership
- Find the team or individual responsible for an asset to allow collaboration.
Your administrator must grant specific permissions if you want to add the products you are working on to this catalog. Contact your administrator for more information.
3.1. Filter components in the Software Catalog
To identify existing software building blocks, view source code, or check lifecycle status, use the catalog filters in RHDH. Filtering the catalog helps you locate production-ready components and documentation without doing manual searches across many repositories.
Procedure
- Log in to the RHDH interface.
- In the navigation sidebar, click Catalog.
- Click the Kind filter and select Component.
- Optional: Click the Type filter to select a functional category, such as Library, Website, or Tool.
- In the Search field, enter the name of the component.
- Select the component card to view the Overview, Docs, and Relationships tabs.
3.2. Analyze microservice dependencies in the Software Catalog
To identify backend applications and microservices, view deployment status, and understand API relationships, use filters in the Red Hat Developer Hub Software Catalog. Filtering helps verify architectural connections and ownership without manually tracing code.
Procedure
- Navigate to the RHDH interface.
- In the left navigation sidebar, click Catalog.
- Click the Kind filter and select Component.
- Click the Type filter and select Service.
-
Optional: Narrow the list by selecting a specific Owner or Lifecycle, such as
productionorexperimental. - Select a service card to open the detailed entity view.
- Review the Overview tab to identify the assigned owner and access links to the source code repository.
- Select the Dependencies or Relations tab to see upstream and downstream connections for that service.
3.3. Review API contracts to verify service endpoints and schemas
To verify endpoints, schemas, and server URLs for your services, locate and inspect API contracts in Red Hat Developer Hub. By reviewing these definitions, you can validate required parameters and data models in a rendered format without searching source code.
Procedure
- Navigate to the RHDH interface.
In the left navigation sidebar, click APIs.
NoteYou can also find these resources by clicking Catalog and selecting API from the Kind filter.
- Select an API from the list to open the detail view.
- Select the Overview tab to examine the metadata, assigned owner, and lifecycle status.
Select the Definition tab to view the rendered specification, such as an interactive Swagger or AsyncAPI interface.
NoteTo test APIs in the RHDH interface before writing a single line of code, you must correctly configure the API definition.
Additional resources
4. Import and use an existing Software Template for faster development
To standardize and accelerate the creation of new software, use Software Templates in Red Hat Developer Hub (RHDH).
Each template uses a YAML definition to present a functional interface for inputting project metadata. Software Templates run a sequential series of actions, such as scaffolding code or creating repositories, which you can configure to run conditionally based on user input.
4.1. Create a software component using Software Templates
To ensure project consistency and reduce manual configuration time, use Software Templates to create new components.
Prerequisites
- You log in to the Red Hat Developer Hub instance.
Procedure
- On the Red Hat Developer Hub navigation menu, click Catalog > Self-service or in the Global Header, click Create (+).
- On the Self-service page, locate the Templates you want to use and click Choose to start the scaffolding process.
- Follow the wizard instructions to enter the required project details.
In the Review step, verify your parameters and click Create.
The scaffolding process begins. You can monitor the progress in the logs or click Cancel to stop the operation.
Verification
If the system creates the component successfully, a success page is displayed.

Troubleshooting
- If the creation process fails, you must review the logs on the error page for specific failure details.
To retry, click Start Over; the system keeps your earlier entered values on the Self-service page.

4.2. Search and filter Software Templates in your Red Hat Developer Hub instance
Search and filter the available Software Templates to quickly locate the correct configuration for your project.
Procedure
- In the Red Hat Developer Hub navigation menu, click Catalog > Self-service.
- In the Search field, enter the name for the Software Template.
- Optional: To refine the results, select a category from the Category list.
4.3. Import an existing Software Template
You can use the Catalog Processor to import an existing Software Template into your Red Hat Developer Hub instance.
Prerequisites
- You have created a directory or repository that has at least one template YAML file or have access to such a directory or repository.
- Optional: To use a template stored in GitHub, you have configured Developer Hub integration with GitHub.
Procedure
-
Open your RHDH
app-config.yamlconfiguration file. In the
catalog.rulessection, add a rule to allowTemplateskinds, as shown in the following example:# ... catalog: rules: - allow: [Template] locations: - type: url target: https://<repository_url/template-name>.yaml # ...where:
catalog.rules.allow-
Specify the
Templaterule to allow new Software Templates in the catalog. catalog.locations.type-
Specify the
urltype when importing templates from a repository (for example, GitHub or GitLab). catalog.locations.target- Specify the full URL to the template file.
Verification
- In the Red Hat Developer Hub navigation menu, click Catalog.
- From the Kind list, select Template.
- Verify that the Template list displays your template.
Additional resources
5. Search for relevant content in Technical Documentation (TechDocs)
To reduce context switching and to ensure technical resources are accessible, use TechDocs in Red Hat Developer Hub. By centralizing documentation, you can review architecture diagrams, installation guides, and component details alongside software entities in a single interface.
5.1. Prerequisites
- Your administrator has enabled and configured the TechDocs plugin.
- Documentation is imported into TechDocs.
- You have the required roles and permissions to access TechDocs content.
5.2. Search for relevant content
To quickly find the information needed for your services, search or filter the TechDocs catalog. Narrowing your search helps you find relevant resources without browsing many repositories.
Procedure
- In the Red Hat Developer Hub navigation menu, click Docs.
On the Documentation page, use the Search bar or filters to locate your document:
- Search: Enter keywords to find specific terms within documents.
- Filter by Owner: View documents owned by specific users or groups.
- Filter by Tags: Narrow results by specific labels or categories.
- Filter by Owned: View documents belonging to you or your group.
Filter by Starred: View your bookmarked favorites.
The results update automatically to show the number of documents that meet your criteria.
6. Verify API contracts before integrating with backend services
To integrate with existing services and understand component communication, use the Red Hat Developer Hub (RHDH) API browser to locate, inspect, and validate API definitions in a centralized interface. You can review API contracts and test endpoints to verify responses directly from the portal.
Apart from viewing specifications, you can use the interactive interface to test available endpoints and review data models. This verification confirms that your application correctly interfaces with backend services before you begin integration.
6.1. Test API endpoints interactively
To verify API behavior and debug service responses, use the interactive test interface in Red Hat Developer Hub. Validating endpoints directly within the portal ensures they return expected status codes and data models, eliminating the need for external testing tools.
Prerequisites
- You have the required credentials or tokens if the API requires authentication.
Procedure
- Navigate to the specific API you must validate and select the Definition tab.
- Locate the operation you want to verify and select the header to expand the details.
- Click Try it out to enable the interactive input fields.
- Enter the required parameters or the request body JSON in the provided fields.
- Click Run.
Examine the Server response section to verify the status code, response body, and headers.
NoteIf you receive 401 (Unauthorized) or 403 (Forbidden) errors, you must verify your credentials with the API owner or check the authorization header requirements in the specification.
6.2. Select supported API specifications
To make API definitions discoverable and interactive within the Red Hat Developer Hub portal, use a supported specification format. The right format allows the platform to render documentation and give testing interfaces for other developers.
6.2.1. Supported API formats
- OpenAPI: Use this standard format (formerly Swagger) for defining RESTful APIs. RHDH renders these specifications into interactive documentation, allowing users to run requests directly from the Definition tab.
- AsyncAPI: Use this format for event-driven architectures and message-based services. This ensures that producers and consumers can visualize message schemas and broker details within the Software Catalog.
- GraphQL: Use this format to define GraphQL schemas. This allows developers to explore your data graph, including queries, mutations, and types, from a centralized location.
Support for specific formats, such as AsyncAPI or GraphQL, depends on your organization’s instance configuration and enabled plugins. If a specification does not render, verify your catalog-info.yaml metadata or contact your platform administrator.
Additional resources
7. Find resources and documentation using search
To find software components, APIs, and technical documentation across the enterprise, use the centralized search feature in Red Hat Developer Hub. This tool helps you locate services, templates, and team members directly, without navigating nested menus.
By using the Search bar, you can access matching resources from the Software Catalog and TechDocs instantly. This unified access reduces the time spent switching between disparate documentation sites or service registries during the development lifecycle.
7.1. Locate resources instantly
To bypass menu navigation and locate technical assets quickly, use the universal search bar in Red Hat Developer Hub. The search engine provides real-time suggestions to navigate directly to services, documentation, or team members, reducing time spent searching.
Procedure
- Click the Search input field in the Global Header.
- Enter your query, such as a service name, API endpoint, or technical concept.
- Review the instant results in the dropdown menu, which categorize matches by entity types such as Components, APIs, TechDocs, and Users.
- Select a suggestion from the list to navigate directly to that resource.
7.2. Filter and refine search results
To isolate specific components, APIs, or documentation, within a large software ecosystem, use the advanced search filters in RHDH. Refining your search results makes sure you can locate production-ready services and ownership details without navigating through unrelated resources.
Procedure
- Enter a search term in the Search bar.
- Click All results….
- In the Filters panel, select one or more of the following options:
- Kind: Filters by entity category, such as Component, API, Template, or Group.
- Type: Narrows the results by functional subtype, such as service, library, or website.
- Lifecycle: Isolates resources by operational status, such as production, experimental, or deprecated.
- Review the filtered results to identify the resource description and owner.
- Optional: Use the pagination controls to navigate the results.
Additional resources
8. Get AI-assisted help for your development tasks
Use Red Hat Developer Lightspeed for Red Hat Developer Hub, a generative AI assistant in Red Hat Developer Hub (RHDH), to ask platform questions, analyze logs, generate code, and create test plans from a conversational interface.
8.1. Prerequisites
- Your platform engineer has installed and configured the Developer Lightspeed for RHDH plugin in your RHDH instance.
8.2. Configure safety guards in Red Hat Developer Hub
To protect users from insecure or harmful AI model outputs, Red Hat Developer Hub (RHDH) uses Llama Guard as a default safety shield. You must configure these guards to align with your organization’s security policies.
Default safety guard configuration-
The system uses Llama Guard as the default safety shield. Override these settings in the
run.yamlfile.
The external_providers_dir parameter defaults to null and is no longer required in your configuration.
Overriding safety guards-
To implement custom security layers or different safety shields, you must define a new safety provider within a custom
run.yamlfile. Disabling safety guards-
To run RHDH without safety guards, you must use the
run-no-guard.yamlconfiguration file.
Running without safety guards increases the risk of invalid model output. Only use this configuration in secure development environments.
Applying the no-guard configuration- To run the system without a safety guard, perform these steps:
Procedure
Add the following YAML file as a config map to your namespace:
version: 2 image_name: redhat-ai-dev-llama-stack-no-guard apis: - agents - inference - safety - tool_runtime - vector_io - files container_image: external_providers_dir: providers: agents: - config: persistence: agent_state: namespace: agents backend: kv_default responses: table_name: responses backend: sql_default provider_id: meta-reference provider_type: inline::meta-reference inference: - provider_id: ${env.ENABLE_VLLM:+vllm} provider_type: remote::vllm config: url: ${env.VLLM_URL:=} api_token: ${env.VLLM_API_KEY:=} max_tokens: ${env.VLLM_MAX_TOKENS:=4096} tls_verify: ${env.VLLM_TLS_VERIFY:=true} - provider_id: ${env.ENABLE_OLLAMA:+ollama} provider_type: remote::ollama config: url: ${env.OLLAMA_URL:=http://localhost:11434} - provider_id: ${env.ENABLE_OPENAI:+openai} provider_type: remote::openai config: api_key: ${env.OPENAI_API_KEY:=} - provider_id: ${env.ENABLE_VERTEX_AI:+vertexai} provider_type: remote::vertexai config: project: ${env.VERTEX_AI_PROJECT:=} location: ${env.VERTEX_AI_LOCATION:=us-central1} - provider_id: sentence-transformers provider_type: inline::sentence-transformers config: {} tool_runtime: - provider_id: model-context-protocol provider_type: remote::model-context-protocol config: {} - provider_id: rag-runtime provider_type: inline::rag-runtime config: {} vector_io: - provider_id: faiss provider_type: inline::faiss config: persistence: namespace: vector_io::faiss backend: faiss_kv files: - provider_id: localfs provider_type: inline::localfs config: storage_dir: /tmp/llama-stack-files metadata_store: table_name: files_metadata backend: sql_files storage: backends: kv_default: type: kv_sqlite db_path: /tmp/kvstore.db sql_default: type: sql_sqlite db_path: /tmp/sql_store.db sql_files: type: sql_sqlite db_path: /rag-content/vector_db/rhdh_product_docs/1.9/files_metadata.db faiss_kv: type: kv_sqlite db_path: /rag-content/vector_db/rhdh_product_docs/1.9/faiss_store.db stores: metadata: namespace: registry backend: faiss_kv inference: table_name: inference_store backend: sql_default max_write_queue_size: 10000 num_writers: 4 conversations: table_name: openai_conversations backend: sql_default registered_resources: models: - model_id: sentence-transformers/all-mpnet-base-v2 metadata: embedding_dimension: 768 model_type: embedding provider_id: sentence-transformers provider_model_id: /rag-content/embeddings_model tool_groups: - provider_id: rag-runtime toolgroup_id: builtin::rag vector_dbs: - vector_db_id: rhdh-product-docs-1_8 embedding_model: sentence-transformers/all-mpnet-base-v2 embedding_dimension: 768 provider_id: faiss server: auth: host: port: 8321 quota: tls_cafile: tls_certfile: tls_keyfile:Mount the config map to your Llama Stack container at
/app-root/run.yamlto make sure it overrides the default image file:name: llama-stack volumeMounts: - mountPath: /app-root/run.yaml subPath: run.yaml name: llama-stack-config
Configure the required volume:
volumes: - name: llama-stack-config configMap: name: llama-stack-configwhere:
llama-stack-config- The config map where you added the new no-guard configuration file.
- Restart the deployment if it does not trigger an automatic rollout.
8.3. Best results for assistant queries
To resolve technical blockers and accelerate development tasks, you must structure your queries to give specific context to the AI assistant. Using precise prompts makes sure that Developer Lightspeed for RHDH generates relevant code snippets, architectural advice, or platform-specific instructions.
Use the following strategies to improve the accuracy of the assistant’s output during your development workflow:
- Specify technologies
- Instead of asking "How do I use templates?", ask "How do I create a Software Template that scaffolds a Node.js service with a CI/CD pipeline".
- Give context
- Include details about your environment, such as "I am deploying to OpenShift; how do I set up my catalog-info.yaml to show pod health?".
- Use conversation context
- Ask follow-up questions to refine an earlier answer. For example, if the assistant gives a code snippet, you can ask "Now rewrite that using TypeScript interfaces."
- Validate with citations
- Check the provided documentation links and citations in the response to verify that the generated advice aligns with your organization’s official standards.
- Improve assistant accuracy
- Rate the utility of responses by selecting the Thumbs up or Thumbs down icons. This feedback helps tune the model for your organization’s specific requirements.
To keep your data secure, do not include sensitive personal information, plain text credentials, or confidential business data in your queries.
8.4. AI response monitoring and context management
Developer Lightspeed for RHDH provides features to track the AI reasoning process and keep the context of your development tasks.
- Thinking cards
- An expandable thinking card is displayed while the AI processes a query. A pulse animation indicates the reasoning phase. You can expand the card to view detailed reasoning or collapse it to minimize screen clutter.
- Tool call transparency
- An expandable card displays details for Model Context Protocol (MCP) tool calls, which you can use to monitor background processes.
- Context-aware citations
- Retrieval-Augmented Generation (RAG) citations appear only when the AI uses internal documentation. This makes sure that general knowledge responses remain concise.
- Context preservation during model changes
- When you select a different AI model, Developer Lightspeed for RHDH starts a new conversation. This keeps your earlier chats available in your history.
- Structural readability
- The interface formats headings and bullet points automatically to make sure responses are scannable.
8.5. Manage chats
Manage your chat history in RHDH to organize your workspace, resume earlier tasks, or find past solutions.

Prerequisites
- You have configured the Developer Lightspeed for RHDH plugin in Red Hat Developer Hub.
- You have logged in to the portal.
Procedure
- Click the Lightspeed floating action button (FAB) at the lower right of the screen to open the chat overlay.
Optional: Configure the interface display:
- Click the Chatbot options icon (⋮) to view chat history or start a new chat.
Click the Display menu icon and select any of the following views:

Overlay: A floating window is displayed over the current page content.

Dock to window: A panel attaches to the right side of the screen. Activating this mode automatically closes the quick start panel if it is already open.

Fullscreen: A dedicated page opens for intensive chat sessions. You can bookmark this URL for direct access.

- Optional: Toggle Enable pinned chats/Disable pinned chats to enable or hide the pinned chats. The system enables this option by default.
Start a chat or load an earlier session:
- Enter a prompt: Type a query in the Enter a prompt for Lightspeed chat field and press Enter.
- Use a sample: Click a prompt tile, such as Deploy with Tekton.
Attach a file: Click Attach to upload a
.yaml,.json, or.txtfile.- Click the file name to open the preview model.
View or edit the content of the file:

- Use voice: Click the Use microphone icon.
- Resume a chat: Select a title from the Recent list.
Organize your chat history:
- Start a new topic: Click New chat to reset the assistant’s context.
- Search history: Enter a keyword in the Search field.
Rename a session: Click Options next to a chat title, select Rename, and enter a new name.

- Pin a chat:: Click Options next to a chat title and select Pin. The chat moves to the Pinned group.
Sort chats:: Click Sort control and choose a sorting criteria, such as Date (Newest first).

Delete a chat: Click Options next to a chat title and select Delete.

- Hide the chat history section and reduce visual noise: Select the Close icon (x) next to New chat.
- Restore access to your pinned chat: Select the Chat history menu icon.
- Optional: To hide the interface, if you are in the Overlay or Dock to window mode, click the Close Lightspeed icon (X) to hide the window. If you are in Fullscreen mode, revert to the other modes and click the Close Lightspeed icon (X). The system preserves your active query and history.
- Optional: In Fullscreen mode, bookmark the URL in your browser to save a direct link to the chat interface.
Verification
- The main window displays the active chat or selected history.
- The chat history list reflects renamed, pinned, or deleted entries.
9. Integrate and customize your daily tools using extensions
To integrate development tools into a single interface and customize your experience, use extensions and plugins in Red Hat Developer Hub. Add plugins to interact with external services such as Jira, Jenkins, or ArgoCD, extending portal capabilities.
9.1. Access platform-wide tools using global plugins
To manage technology standards, track project costs, or access AI help, use the global plugins located in the main navigation sidebar of Red Hat Developer Hub (RHDH). These plugins give features that apply across the whole portal instead of to a specific software entity.
Procedure
- Log in to your RHDH instance.
- In the left navigation sidebar, locate the standard or custom items that represent specific global extensions, such as:
- Tech Radar: Use this to visualize your organization’s approved and deprecated technologies.
- Cost Insights: Use this to track and analyze cloud infrastructure spending for your projects.
- Developer Lightspeed for RHDH: Access this conversational interface for AI-assisted development help and platform queries.
- Learning Paths: Access training and educational resources to improve your technical skills.
9.2. Review RHDH resource data
To review data specific to a particular resource in RHDH, use entity plugins that appear when viewing components, services, or APIs in the Software Catalog.
Procedure
- Navigate to the RHDH interface.
- In the left navigation sidebar, click Catalog.
- Select a Component or Service card.
- Review the tabs at the top of the entity page to view configured plugins:
- CI/CD: Displays build status and history from tools such as Jenkins or GitHub Actions.
- Kubernetes: Shows deployment status and pod health.
- Topology: Visualizes the relationships and status of running resources.
Next steps
- If a build fails in the CI/CD tab, select the build number to view the logs in the source provider.
- If a pod is failing in the Kubernetes tab, examine the error events to troubleshoot the deployment.
9.3. Identify integrations in the RHDH extensions marketplace
To enhance your development workflow with additional tools, browse the extensions marketplace in Red Hat Developer Hub. Identifying available plugins shows which integrations are active or which supported tools your team can request to improve visibility and automation.
Procedure
- In the left navigation sidebar, click Extensions.
- Browse the marketplace to review the following categories:
- Installed: Review the integrations currently active in your instance, such as Jira, ArgoCD, or GitHub.
Available: Examine additional integrations supported by the platform that are not yet enabled for your workspace.
NoteEnd users typically cannot install plugins. If you locate a plugin in the marketplace or the Backstage Plugin Directory that your team requires, contact your administrator to request its installation.
Additional resources
10. Customize your RHDH interface settings
Personalize your Red Hat Developer Hub (RHDH) environment to align the portal with your system preferences and optimize your workspace. Reviewing your user profile also confirms your account details and software ownership in the Software Catalog.
10.1. Customize your interface settings and profile details
Personalize your workspace appearance and verify that you are correctly associated with your team’s services.
Procedure
- In the RHDH global header, click your avatar or name to open the user menu.
To customize the interface:
- Select Settings.
In the Appearance section, configure the following options:
- Theme: Select Light, Dark, or Auto to synchronize the portal with your operating system preferences.
- Language: Select your preferred interface language from the list.
- Pin Sidebar: Use this toggle to keep the left navigation menu expanded. The system enables this feature by default.
To check your identity and software ownership:
- Open the user menu again and select My Profile.
- Review the About card to confirm that your account details, such as email and team tags, are right.
- Examine the Ownership card to identify the software components, APIs, and systems linked to your identity.
Use the relations toggle to switch between the following views:
- Direct Relations: View entities where you are explicitly listed as the owner.
- Aggregated Relations: View entities inherited through team memberships or group hierarchies.
11. Manage starred items for quick access
To streamline your daily workflow and reduce navigation time, use the starring feature in Red Hat Developer Hub. By starring key components, APIs, and services in the Software Catalog, you create a personalized list accessible from your sidebar or homepage.
This personalization makes sure that you can locate the specific tools and documentation you use most often without performing repetitive searches across the software ecosystem.
11.1. Star key components in the Software Catalog
You can add commonly used components to the Your Starred Entities card for quick access.
Procedure
- In the Red Hat Developer Hub navigation menu, select Catalog.
- Locate the components you want to add as a favorite.
- In the Actions column for that component, click the Add to favorites (star) icon.
Verification
- Navigate to the Home page and verify that the Your Starred Entities card lists the component.
Additional resources
