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. Searching 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. Managing starred items for quick access
As a new developer, you will learn how to personalize your experience by customizing settings and starring frequently used items, enabling you to independently find the software catalog, templates, and documentation you need.
1. Purpose and structure of Red Hat Developer Hub
To streamline your software development lifecycle, your organization has chosen to use Red Hat Developer Hub (RHDH) as your primary internal developer portal (IDP).
RHDH offers a unified interface to manage infrastructure, generate software projects, use tools and services, and access technical documentation in a centralized location.
- The developer experience challenge
- Modern software development often involves fragmented workflows. Developers frequently switch contexts between code repositories, ticketing systems, CI/CD pipelines, monitoring dashboards, and so on. This fragmentation creates information silos and increases the time required to find API documentation, service ownership details, or deployment status.
- Improving developer productivity with RHDH
RHDH centralizes fragmented technical resources to streamline the developer experience. The platform provides the following advantages:
- Unified discovery: Locate applications, APIs, and documentation in a single, accessible location.
- Search capabilities: Find users, groups, and catalog using an integrated search feature. Once indexed, all entities become discoverable across the entire ecosystem within seconds.
- Self-service capabilities: Create projects and deploy services using automated Software Templates. This ensures consistency and reduces reliance on manual ticketing.
- Service visibility: Map relationships between services, dependencies, and API contracts to clarify ownership and component linkages.
- Extensibility: Integrate external tools, such as monitoring dashboards and pipelines, directly into the portal to create a unified interface.
2. Log in to Red Hat Developer Hub
To access your organization’s software catalog, templates, and documentation, you must authenticate with Red Hat Developer Hub (RHDH) using your configured identity provider. With secure authentication, you have the appropriate permissions to view and manage software entities linked to your role.
By logging in, you gain entry to a centralized portal that streamlines your development workflow. This secure access allows you to locate required software building blocks and documentation without navigating multiple disparate systems.
3. Find software components to discover assets
To integrate with existing software, verify ownership, or prevent redundant development, use the Software Catalog in Red Hat Developer Hub (RHDH). You can use this centralized inventory to discover assets without searching through multiple 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 facilitate 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.
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). You can generate consistent software components, publish them to Git repositories, and register them in the Software Catalog to make sure they are discoverable across your organization.
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. Creating a software component using Software Templates
To ensure project consistency and reduce manual configuration time, use Software Templates to create new components. These templates automate the scaffolding process, providing a pre-configured project structure directly from your Red Hat Developer Hub portal.
Prerequisites
- You are logged 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 component is created successfully, a success page appears.

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 retains your previously entered values on the Self-service page.

4.2. Searching and filtering Software Templates in your Red Hat Developer Hub instance
To quickly locate the correct configuration for your project and reduce time spent browsing the catalog, search and filter the available Software Templates. Narrowing your search ensures you select the specific template that meets your development requirements.
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. Importing 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 contains at least one template YAML file.
- 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 your template appears in the Template list.
Additional resources
5. Searching for relevant content in Technical Documentation (TechDocs)
To reduce context switching and to make sure technical resources are accessible, use TechDocs in Red Hat Developer Hub. Centralizing documentation allows you to review architecture diagrams, installation guides, and component details alongside software entities in a single interface.
Prerequisites
- The TechDocs plugin is enabled and configured.
- Documentation is imported into TechDocs.
- You have the required roles and permissions to access TechDocs content.
5.1. Search for relevant content
To quickly find the information required for your services, search or filter the TechDocs catalog. Narrowing your search makes sure you find relevant resources without browsing multiple 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.
5.2. Access and navigate documentation
Use the built-in navigation tools to move between related documents within a book. This ensures you can easily reference implementation details and requirements in a logical sequence.
Procedure
- In the Red Hat Developer Hub navigation menu, click Docs.
- In the Documentation table, click the name of the document you want to view.
Navigate the content using the following on-screen tools:
- Search bar: Find keywords within the current document.
- Table of contents: Jump to specific sections.
- Navigation menu: Switch between different documents in the same book.
- Next: Proceed to the next sequential document.
- Add-ons: Perform additional actions if plugins are configured, such as setting the text size.
Additional resources
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 (RHDH). Validating endpoints directly within the portal makes sure they return the expected status codes and data models, which eliminates the need to configure external testing tools during the initial integration phase.
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 Execute.
- Examine the Server response section to verify the status code, response body, and headers.
If 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 sure your API definitions are discoverable and interactive within the Red Hat Developer Hub (RHDH) portal, you must use a supported specification format. Selecting the appropriate format based on your service architecture allows the platform to render documentation and provide testing interfaces for other developers.
Supported API formats
- OpenAPI: Use this standard format (formerly Swagger) for defining RESTful APIs. RHDH renders these specifications into interactive documentation, allowing users to execute 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 (RHDH). By indexing the entire software ecosystem, this tool helps you locate services, templates, and team members directly, without navigating through 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 (RHDH). The search engine provides real-time suggestions to help you navigate directly to services, documentation, or team members, which reduces the time spent searching across disparate repositories.
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
To assist with development tasks, platform questions, and debugging, use Red Hat Developer Lightspeed for Red Hat Developer Hub, a generative AI virtual assistant integrated directly into Red Hat Developer Hub (RHDH). You can use the conversational interface to ask platform-specific questions, analyze logs, generate code, and create test plans, which reduces the time spent searching through official documentation or disparate tools.
8.1. 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 unvalidated 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.
Prerequisites
- Your platform engineer has installed and configured the Developer Lightspeed for RHDH plugin in your RHDH instance.
8.2. Get the best results for assistant queries
To resolve technical blockers and accelerate development tasks, you must structure your queries to provide specific context to the AI assistant. Using precise prompts ensures 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".
- Provide context
- Include details about your environment, such as "I am deploying to OpenShift; how do I configure my catalog-info.yaml to show pod health?".
- Leverage conversation context
- Ask follow-up questions to refine a previous answer. For example, if the assistant provides a code snippet, you can ask "Now rewrite that using TypeScript interfaces."
- Validate with citations
- Examine 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 maintain security standards, do not include sensitive personal information, plain-text credentials, or confidential business data in your queries.
8.3. Monitor AI responses and context management
Developer Lightspeed for RHDH provides features to track the AI reasoning process and maintain the context of your development tasks.
- Thinking cards
- An expandable thinking card appears 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 allows you 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 makes sure that your previous chats remain available in your history.
- Structural readability
- The interface formats headings and bullet points automatically to make sure responses are scannable.
8.4. Managing chats
Manage your chat history in RHDH to organize your workspace, resume previous tasks, or find past solutions.

Prerequisites
- You have configured the Developer Lightspeed for RHDH plugin in Red Hat Developer Hub.
- You must be logged in to the portal.
Procedure
- Click the Lightspeed floating action button (FAB) at the bottom 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 appears over the current page content.

Dock to window: A panel attaches to the right side of the screen. Activating this mode automatically closes the Quickstart 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. This is enabled by default.
Start a chat or load a previous 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 your development tools into a single interface and customize your experience, use the extensions and plugins in Red Hat Developer Hub RHDH. While core features such as the Software Catalog and TechDocs are pre-installed, you can add plugins to interact with external services such as Jira, Jenkins, or ArgoCD. By discovering global features in the navigation sidebar or reviewing entity-specific data in the catalog, you extend portal capabilities and access information from your daily tools directly within the portal.
9.1. Access platform-wide tools using global plugins
To manage technology standards, track project costs, or access AI assistance, use the global plugins located in the main navigation sidebar of Red Hat Developer Hub (RHDH). These plugins provide features that apply across the entire portal rather than 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: 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 (RHDH). Identifying available plugins allows you to see which integrations are currently active or which supported tools your team can request to improve project 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.
End 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 enablement.
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. This feature is enabled by default.
To verify 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 accurate.
- 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. Managing starred items for quick access
To streamline your daily workflow and reduce navigation time, use the starring feature in Red Hat Developer Hub (RHDH). By starring key components, APIs, and services in the Software Catalog, you create a personalized list of high-priority resources accessible directly from your sidebar or homepage.
This personalization makes sure that you can locate the specific tools and documentation you use most frequently without performing repetitive searches across the software ecosystem.
11.1. Starring key components in the Software Catalog
You can add frequently 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 the component is listed in the Your Starred Entities card.
Additional resources
