DEV Community: Rely.io

Introducing Engineering Performance - Boost Team Productivity with Intelligent Engineering Metrics

Tiago Barbosa — Tue, 21 Jan 2025 12:22:24 +0000

At Rely.io, we're excited to launch Engineering Performance, a groundbreaking feature in our Internal Developer Portal that transforms how engineering teams understand and optimize their workflow. This tool provides unprecedented insights into team productivity, helping leaders make data-driven decisions and empowering developers to continuously improve their performance.

Key highlights:

Automated performance tracking across development lifecycles
Comprehensive metrics that reveal team and service productivity
Actionable insights to streamline service reviews and optimize workflows

Engineering Performance represents our commitment to helping teams work smarter, not harder.

Why do you need Engineering Performance View?

Engineering leaders today face an increasingly complex landscape of challenges. In an era of rapid technological advancement, the pressure to deliver high-quality software quickly has never been more intense. Organizations are constantly juggling multiple critical objectives: accelerating time-to-market, maintaining rigorous security standards, controlling operational costs, and keeping teams motivated and high-performing.

The Measurement Challenge

Traditional approaches to understanding team performance are fundamentally broken. Most engineering leaders find themselves drowning in a sea of disconnected data:

Metrics scattered across multiple tools
Lack of meaningful context
Retrospective insights that come too late

Imagine trying to navigate a ship without a compass, constantly reacting to challenges instead of proactively addressing them. This is the reality for many engineering teams today.

The consequences of this fragmented approach are profound. Without comprehensive performance insights, organizations risk:

Undetected workflow bottlenecks
Delayed recognition of service degradation
Inefficient resource allocation

Engineering leaders are left asking critical questions with no clear answers: Are we meeting our delivery commitments? Where are our true performance weaknesses? How can we support our teams more effectively?

A New Approach to Performance

Engineering Performance represents a fundamental shift. We've designed a solution that goes beyond traditional metrics, providing a holistic view of team and service performance. It's not just about collecting data, it's about transforming that data into actionable intelligence that drives continuous improvement.

By bringing context, clarity, and predictive insights to your engineering workflow, we empower leaders to make informed decisions, support their teams more effectively, and drive meaningful organizational change.

Beyond Traditional Metrics

Engineering performance measurement has long been trapped in a narrow, one-dimensional view. Frameworks like DORA and SPACE have provided valuable insights, but they only scratch the surface of what truly drives engineering excellence.

The Limitations of Existing Frameworks

Traditional productivity metrics offer a limited perspective. They might tell you how quickly code is delivered, but they fail to capture the nuanced reality of modern software development. A team's success is about more than just lines of code or deployment frequency, it's about the holistic health of your services and the effectiveness of your engineering ecosystem.

A Comprehensive Performance Lens

Our Engineering Performance feature breaks through these limitations, providing a multi-dimensional view of your engineering organization:

Deep service performance insights
Comprehensive team productivity tracking
Contextual understanding of organizational standards
Powerful benchmarking capabilities

Benchmarking: Your Performance in Context

One of the most powerful capabilities of Engineering Performance is its ability to provide comparative insights. Teams and services can now be measured against the organizational performance, giving you a clear view of:

How your specific services perform relative to company-wide trends
Whether a team is outperforming or underperforming compared to peers
Identifying best practices from top-performing teams
Understanding your organization's overall performance landscape

This isn't about creating competition, but about providing actionable insights that help every team improve and learn from each other.

More Than Just Numbers

We understand that every engineering organization is unique. What matters most is not a universal benchmark, but the metrics that are truly meaningful to your specific business goals. Whether you're tracking critical feature delivery, monitoring security initiatives, or optimizing service reliability, Engineering Performance adapts to your organization's unique priorities.

The Context Advantage

Unlike isolated metrics tools, our approach is deeply contextual. We don't just present numbers, we provide a rich, interconnected view of your engineering landscape. This means you can understand not just what is happening, but why it's happening and how different aspects of your engineering process interact.

By moving beyond traditional metrics, Engineering Performance empowers you to see the full picture of your team's performance, potential, and possibilities.

Engineering Performance: Powered by Your Developer Portal

The modern engineering organization needs more than just a metrics tool - it needs a central nervous system that connects insights, context, and action. This is where the power of an internal developer portal becomes transformative.

A Single Source of Truth

Your developer portal is already the central repository of your engineering ecosystem. Engineering Performance doesn't just sit on top of this system - it's deeply integrated, leveraging the rich context already present in your software catalog.

This integration means every metric comes with a full contextual backdrop:

Understanding which teams own specific services
Connecting performance data to actual software entities
Providing immediate insight into potential impacts of performance variations

Beyond Passive Observation

Unlike traditional reporting tools, Engineering Performance turns insights into action. The developer portal becomes more than just a dashboard, it's a strategic platform for driving organizational improvement.

Imagine being able to:

Instantly correlate a performance dip with specific service dependencies
Understand the broader implications of a team's metrics
Create targeted interventions based on comprehensive insights

The Power of Contextual Intelligence

By embedding performance metrics directly into your developer portal, we break down the walls between data, understanding, and action. Each insight is immediately actionable, connected to the real-world context of your engineering organization.

This approach transforms performance metrics from passive reports into dynamic, living intelligence that can drive real change.

Navigating Your Engineering Performance

Engineering Performance provides a comprehensive toolkit for identifying and addressing key areas of improvement across your organization. It's not just about measuring—it's about understanding and enhancing your engineering ecosystem.

Service Performance Optimization

Teams can now dive deep into service-level insights:

Track service reliability and stability
Understand deployment frequency and quality
Compare service performance across your organization

Workflow Efficiency

Gain unprecedented visibility into your development workflows:

Analyze cycle times for different types of work
Understand review processes and collaboration patterns
Identify areas where teams can streamline their processes
Benchmark team productivity against organizational trends

Operational Excellence

Go beyond surface-level metrics to drive meaningful improvements:

Track compliance with organizational standards
Understand the impact of different development practices

Continuous Improvement Framework

Engineering Performance transforms performance data into a proactive improvement tool. It's not about pointing out weaknesses, but about providing a clear path to enhancement. Each insight comes with the context needed to make informed decisions, helping teams:

Understand their current performance
Identify specific areas for growth
Track the impact of improvement initiatives
Celebrate and learn from high-performing teams

What's Coming Next

At Rely.io, we're committed to continuously evolving Engineering Performance to meet the dynamic needs of modern engineering organizations. Our roadmap is driven by the real challenges and opportunities we see in the engineering ecosystem.

Upcoming Innovations

We're excited to share a glimpse of our future developments:

Deeper integrations with popular development and DevOps tools
More granular customization options for performance tracking
Advanced anomaly detection and comprehensive alerting capabilities
AI Agentic Workflows to support automated healing and correction of missing standards

Our Product Philosophy

Our approach has always been about empowering engineering teams with actionable, contextual intelligence. The features we're developing will continue to push the boundaries of what's possible in engineering performance management.

We're not just building a tool—we're creating a platform that helps engineering organizations unlock their full potential, drive continuous improvement, and make more informed strategic decisions.

Ready to Transform Your Engineering Performance?

See Engineering Performance in action and discover how Rely.io can elevate your team's potential.

Book a Demo with our Platform Architects or sign up for a free trial.

Don't just measure performance—transform it with Rely.io.

Stay Tuned

The engineering landscape is constantly evolving, and so are we. We're committed to staying at the forefront of engineering intelligence, continuously listening to our customers and the broader engineering community.

Keep an eye out for upcoming announcements and feature releases. The best is yet to come.

Rely.io Update Roundup - December 2024

Tiago Barbosa — Tue, 07 Jan 2025 10:46:06 +0000

As we wrap up the year, our focus this December has been on enhancing usability, delivering deeper insights, and expanding the power of Rely.io with new capabilities. Let’s explore what’s new this month.

[Beta] Find performance bottlenecks in minutes

Last month, we introduced the “Performance Review” page as a beta feature, designed to provide actionable insights into your engineering operations. Since then, we’ve been hard at work to deliver its next planned iteration while also incorporating your feedback to make this tool even more powerful and user-friendly.

This new iteration brings the following improvements:

‍Renamed Feature

Following your feedback, the page is now called Engineering Performance instead of Performance Reviews, which aligns better with engineering efficiency concerns and avoids confusion with personal reviews from the HR world.

Improved filters

‍The simple dropdowns from the previous version have now been replaced by cumulative filters for Teams and Services. Each filter is also reactive to the other based on the owner relationship between Services and their Team. With these, you can now narrow down your focus on the scope that matters to you and review Engineering Performance for specific teams or services under your purview.

New tabs

‍In order to bring clarity and additional context to the information shown, the page now includes tabs that represent specific areas of interest (e.g. Productivity, Security, etc.)‍

Overview tab: When performing a quick review “at a glance” you need to find in one place the most important information that will immediately highlight standouts on which you should focus your attention first. This new tab includes a hand picked selection of critical information from the other tabs and surfaces them in on simple view. This selection will evolved over time based on your feedback as well as the growth of the feature (e.g. with the future addition of a “security” tab).In this iteration, the tab includes critical productivity metrics (PR Cycle time, Change Lead Time and MTTR) as well as the Production Readiness Scorecard. You can click on each requirement to drill-down on it and find which services or teams are compliant or not.

Productivity tab: This tab includes a selection of coding and deployment practices related metrics helping you quickly assess if and where any bottleneck exist there. There are currently 9 metrics covered that will evolve based on customers feedback and usage.

Display Control

In order to keep the graphs legible (and avoid spaghettification), not all entities that fit your filters have to be displayed at the same time. Using the Display Control button, you can select which entities should explicitly shown or not. For all the ones not shown, they do not disappear and are actually surfaced as an “aggregated” curve so that their contextual value is never lost.

With enhancements to the filters, aggregated values, and drilldowns, the Performance Review Page now offers unparalleled visibility and usability, ensuring you can pinpoint bottlenecks and take decisive action with ease.

The Engineering Performance views are still available in Beta.

If you want to try them for your organization, let us know!

Enhance Compliance and Discovery with File Analysis

All plugins now include support for a new filesToCheck capability, giving you deeper insights into the files and configurations in your repositories. This feature allows plugins to inspect specific files chosen by you, enabling:

Enhanced Software Catalogs: Automatically populate and validate metadata taken from within the file’s content for better service discovery.
Improved Scorecards: Verify compliance with essential standards by perusing file contents, such as ensuring service.yaml files are properly filled.

This capability empowers teams to maintain high standards effortlessly and ensures critical details don’t slip through the cracks.

File Analysis is generally available for all users.

On the Horizon

Here’s a preview of features coming next:

Engineering Performance GA: On top of the performance metrics announced above, Engineering Leaders can review more metrics and include Scorecards for their Teams, Services & Domains.‍
Automated Actions for Engineering Performance: Turn insights from the Engineering Performance views into automated and actionable tasks to efficiently lead teams to perform the changes that will drive performance up.
Onboarding Wizard for Free Trials: New users will soon benefit from a step-by-step guide, taking them from first login to actionable insights like DORA metrics in under five minutes.‍
Guided Experience for Adding Plugins: Soon, we’ll be bringing the new configuration wizard to the journey for adding new plugins, ensuring every step is clear and efficient there too.‍
Standardized Plugins: Look out for improvements as we standardize more plugins by type (Incident Management, Observability, CI/CD), making integrations even more seamless.

As well as our next incoming Plugins:

Jira
ServiceNow
Incident.io
Rootly
Jenkins
Linear

Not a user yet?

If you’re looking for an Internal Developer Portal or are simply interested in trying everything we described here, you can get started for free with Rely.io.

Want to see Rely.io in action? Get started with your free trial here.

Why does improving Engineering Performance feel broken?

Tiago Barbosa — Tue, 17 Dec 2024 17:40:25 +0000

Many engineering teams conduct performance reviews (these are not individual performance reviews, we’re talking about going over a team’s assets and practices) that feel like a blame game or an exercise in vanity metrics, leading to frustration, finger-pointing, and no meaningful improvements.

Yet companies continue this exercise because the stakes are high: engineering performance directly impacts delivery speed, product quality, developer satisfaction, and ultimately, business outcomes. Without a structured review process, teams can miss critical bottlenecks, lose visibility into progress, and stall improvements.

Done right, engineering reviews can uncover bottlenecks, celebrate successes, and provide a clear, actionable plan to improve delivery, quality, and developer experience.

Or so goes the common belief… especially among the management.

This guide is for Engineering Leaders – CTOs, VPs, Heads, Directors, EMs – who want to drive performance but are still tinkering to find the right process and align teams on outcomes.

Do we even need Engineering Performance Reviews?

What even constitutes a review of Engineering Performance?

At its core, an engineering performance review is a process of analyzing how teams, systems, and workflows contribute to delivering software efficiently, reliably, and sustainably. It can include quantitative metrics, qualitative feedback, and outcomes alignment.

The reality is, we all do it, whether systematically, in an organized way or not, and at every scale:

In startups, “reviews” happen organically as developers debate and settle on a few practices to follow so they have some semblance of consistency in their code (Are you team tab or spaces?, documentation practices, etc.
In small teams within larger companies, reviews ensure alignment and smooth handoffs between developers, increasing shared ownership, reducing ramp-up times and facilitating internal rotations.
In mid-sized organizations, reviews address collaboration across teams to ensure operational excellence.
In large companies or enterprise settings, they scale to departments, business units, and entire organizations to tackle systemic challenges and improve accountability.

What do we typically hope to get from it?

Continuous Improvement: Reviews uncover strengths and weaknesses, enabling systemic changes to improve productivity, delivery speed, and code quality. In the end, it’s also about DevEx – imagine how painful collaboration would be if every code change or resource adjustment felt as convoluted as a bureaucratic process. Now project that inefficiency across thousands of developers.
Accountability: Reviews promote transparency and shared ownership. Teams gain clarity on how their contributions tie to the bigger picture and business outcomes.
Alignment: Reviews offer a structured forum to align engineering work with overarching company goals. They ensure teams’ focus on solving the right problems.
Celebrating Wins: Often overlooked, reviews recognize achievements, highlight progress, and motivate teams to sustain momentum.
Visibility: Engineering leaders gain a clear understanding of team performance, bottlenecks, and progress toward shared objectives.

So, is this just a “big company thing”?

No. The need for engineering reviews exists at every scale because improving collaboration, accountability, and efficiency is essential for all teams.

The difference? At scale, processes that worked informally begin to break down, creating frustrations for both leadership and teams. What once enabled quick collaboration now feels like a painful exercise in finger-pointing or red tape.

The challenge is clear: how do we scale engineering performance reviews so they deliver the intended value without creating overhead or mistrust?

Why Traditional Engineering Reviews Fall Short

Engineering reviews often begin with good intentions but fall apart in execution. Why? Because the process itself feels disconnected from the teams it aims to serve.

First, the exercise feels forced. Too often, reviews are initiated by leadership without input from the engineers on the ground. Instead of an opportunity for teams to reflect and improve, they can feel like a mandate from above, imposed rather than embraced.

Second, they are painful and unfair from the outset. Measuring engineering performance relies on KPIs that most organizations don’t have readily available. The irony? The burden of collecting these metrics almost always falls on engineers. Instead of focusing on their work, they find themselves wrestling with sporadic code instrumentation, custom database queries, or extracting data from multiple developer tools – tedious, manual, and thankless tasks performed for leadership’s benefit.

The next problem is priority. Engineering reviews inevitably compete with business as usual – and rarely win. Product engineers, for example, are evaluated and rewarded for delivering features, not collecting data for compliance or operational reviews. Why would they prioritize a process that doesn’t contribute to their career growth? It becomes an exercise without a clear value proposition.

Even when the data is collected, reviews face a trust problem. Metrics alone are rarely enough. They offer a partial picture at best, stripped of the context that explains why a team’s performance may look the way it does. Worse, these metrics are often compiled manually into static datasets – outdated, inaccurate, and impossible to drill into. A single point-in-time snapshot rarely reflects the nuanced, ongoing story of engineering work.

And finally, the outcome feels disconnected. Reviews often produce results that engineers simply don’t recognize. A spreadsheet of metrics suggesting “team X isn’t deploying often enough” lands like a punchline without context. Teams roll their eyes at comparisons to Google’s benchmarks or abstract best practices, which often ignore the unique challenges they face.

When reviews are forced, painful, and untrusted, they lose their potential to drive change. Instead of creating alignment and improvement, they become divisive exercises that highlight friction between leadership and teams.

Treat Engineering Teams Like Customers, Not Direct Reports

As the title of this section suggests, there is a way out of the cursed corner that engineering reviews have painted themselves into—and the good news is that it doesn’t require recreating rotary-to-linear motion conversion devices. The key is to apply well-known principles, often borrowed from platform engineering and product management, to how reviews are structured and executed.

A core tenet of platform engineering is to treat developers as customers. As a platform team, you act like a product manager, delivering capabilities that solve real pain points for your users. These aren’t features that make your life easier; they’re built to empower developers, removing obstacles and enhancing productivity.

So why can’t engineering leaders apply the same mindset when approaching engineering performance?

Imagine this: Instead of saying, “We need to report DORA metrics to leadership,” make it a collaborative journey with the teams themselves. Even if it’s a top-down request, the framing matters—engaging teams as co-creators ensures buy-in and ownership.

Start the Journey with Questions

Much like product discovery, onboarding teams into the performance improvement journey starts with understanding their perspectives. Ask open-ended, collaborative questions like:

Where do you believe we are most inefficient? Why?
How do you think we fare compared to the rest of the org?
Where should we improve first, and why?
How much effort should we put into this issue? For what result, knowing what we have on our plate already?
What impact do we foresee on deliveries? How should we sell this up the chain?

Let Teams Cook

Answering these questions is no easy task, even for experienced teams. Resist the temptation to jump in with pre-baked solutions—instead, give teams the space to propose their own ideas.

The process is more valuable than the outcome at this stage. Let them ideate and push back constructively, much like a product brief review:

Would this be an accurate representation of our performance?
Would this be easily understandable by other teams? By higher-ups?
Can this be extended or reproduced by other teams, or is it too context-specific to our work?

Facilitate the Team’s Own Goals

This is where the engineering leader’s role becomes pivotal: as a facilitator, not a dictator. Your experience in aligning internal team goals with organizational priorities is crucial. Teams need your help to shape their ideas into coherent, actionable plans that resonate both internally and with leadership.

Propose frameworks, compliance standards, or engineering performance tools as means to an end—not as rigid mandates:

“Like developing a product or a feature, let’s start small and iterate success after success.”
“Yes, all these frameworks and tools might have inaccuracies or inherent unfairness, but they offer a battle-tested starting point.”
“Most importantly, they save us time and effort, allowing us to focus on gaining internal momentum, showing progress and delivering early wins.”

By treating engineering teams like customers, engineering leaders can transform reviews into a collaborative, empowering process. Teams become active participants in their performance journey, owning both the challenges and the solutions, while leadership gains the actionable insights they need without alienating the people doing the work.

Conclusion: Reimagining Engineering Performance Reviews

Engineering performance reviews are critical but often feel broken because of misaligned processes, forced mandates, and a lack of trust. By treating engineering teams like customers—engaging them as co-creators, asking the right questions, and facilitating their goals—leaders can transform reviews from painful chores into empowering, collaborative exercises. The key is to focus on creating alignment, celebrating wins, and fostering continuous improvement without the overhead or mistrust that typically derails these efforts.

Engineering performance reviews shouldn’t be about hitting abstract benchmarks or generating metrics for leadership’s sake. Instead, they should serve as opportunities for teams to uncover bottlenecks, align on priorities, and drive meaningful, systemic change. With the right mindset and approach, reviews can become a cornerstone of engineering success, balancing leadership’s need for visibility with teams’ desire for autonomy and recognition.

What’s Next? How to Conduct Effective Engineering Performance Reviews

In the next article, we’ll dive into the how. You’ve understood the pitfalls of traditional reviews and the principles for a better approach. But what does an effective process look like in practice? How do you define goals, measure progress, and ensure actionable outcomes? We’ll explore frameworks, tools, and real-world examples to help you design and execute engineering performance reviews that deliver results—without the pain.

Stay tuned for a step-by-step guide to transforming engineering performance reviews into a process that empowers teams and drives sustainable improvements.

Top Backstage alternatives

Tiago Barbosa — Tue, 17 Dec 2024 17:32:21 +0000

As engineering teams scale, managing tools, services, and workflows efficiently becomes critical. Developer portals like Backstage help address this complexity, but they’re not a one-size-fits-all solution. Whether due to Backstage’s steep learning curve, resource-heavy implementation, or lack of specific features, many teams look for alternatives that better align with their needs.

In this post, we’ll explore some of the top Backstage alternatives, comparing their strengths and weaknesses to help you find the best fit for your team. We’ll also highlight how Rely.io stands out as a modern, lightweight, and feature-rich option for teams seeking to streamline their development workflows.

Why Consider Alternatives to Backstage?

Backstage, developed by Spotify, is a powerful open-source platform for building developer portals. However, it comes with challenges:

Implementation Complexity: Backstage often requires significant engineering effort to customize and maintain, which can be a barrier for smaller teams.
Resource Intensity: Running Backstage demands infrastructure and dedicated resources to manage, often taking away engineering capacity from already undersized DevOps, SRE or Platform Engineering teams.
Feature Gaps: While Backstage shines as a service catalog, some teams find it lacking in features like detailed compliance tracking or integration flexibility.
Toil heavy migrations & updates: As an open-source project, Backstage has many key components developed and maintained by different vendors. They each have their own update schedules which often introduce breaking changes downstream in other dependent components.

If these challenges resonate with you, there are modern solutions that address these limitations and provide new opportunities for your team.

Rely.io: The Smart, Opinionated Alternative

Rely.io is built around the philosophy of "low floor, high ceiling," making it both approachable for new users and powerful enough for advanced customization. The platform is designed to be as opinionated as possible, addressing the most common use cases right out of the box to save time and effort for users. At the same time, Rely.io acknowledges that every organization is unique, offering an extensive toolset of customizations to adapt to varying needs.

As a vertical product, Rely.io delivers tailored experiences for specific user needs, ensuring clarity and actionable insights. For example, in the pursuit of engineering excellence—a primary reason companies seek internal developer portals—Rely.io provides Engineering Performance views. These views not only highlight bottlenecks in workflows but also offer suggested remediations, empowering teams to take actionable steps toward improvement.

Key Features of Rely.io:

Dynamic Software Catalog: Automatically syncs with tools like GitHub, Jira, and Kubernetes, providing an always-up-to-date and trusted system of records into your software and infrastructure ecosystems.
Compliance and Quality Tracking: Scorecards track and enforce standards across teams and services, giving clear insights into performance (e.g. DORA, SPACE, …), security, quality, and operational health.
Out-of-the-box Analytics: Plugins come packed with opinionated data and formulas for users to visualize from Day 1 engineering KPIs like deployment frequency, lead time, PR cycles, and more.
Engineering Performance Review: Engineering Leaders should not have to dig into the Catalog to identify performance bottlenecks or non-compliance with Engineering Standards. These opinionated views bring to their attention the relevant data to implement effective initiatives.
No Toil Deployment: Rely.io is SaaS-based, eliminating the need for complex infrastructure and ongoing maintenance.
Built-In Guidance: Opinionated features at every turn guide users toward best practices, reducing decision fatigue and setup time.
Extensive Customization: Adapt workflows, dashboards, and metrics to match your organization’s specific DNA without introducing unnecessary complexity.

By addressing the common pain points of traditional developer portals and balancing pre-configured use cases with advanced customization, Rely.io enables teams to focus on building great software while maintaining operational excellence.Read more about how Backstage and Rely compare to each other in this dedicated article.

Building Your Own Solution

From Scratch: Building a developer portal from scratch gives your team full control and unlimited customization possibilities. This approach often starts with piecemeal solutions, such as creating a service catalog using spreadsheets, CMDBs, or simple dashboards. Some teams extend their CI/CD tooling, like Jenkins or GitHub Actions, to include self-service capabilities.

Over time, these efforts may evolve into a fully-fledged in-house portal, tailored to the organization’s workflows. However, the initial investment in time and resources rarely matches reality. Teams often find themselves facing either underwhelming results—such as long delivery cycles, low adoption rates, and limited functionality—or overwhelming complexity as more resources are added to the project to address growing demands.

This escalation can even reach the point where active Product Management is required to maintain and evolve the solution, further increasing sunk costs and creating a cycle of dependency on internal resources. As organizational requirements evolve—whether through changes in processes, tech stacks, or compliance standards—these in-house portals often reach a breaking point, demanding costly overhauls or rewrites.

The sunk cost dilemma often emerges here: Should the team continue investing heavily in maintaining their portal, or transition to a commercial solution? Many find that modern commercial platforms replicate the functionality of in-house solutions while offering broader features like automations, compliance tracking, and developer experience enhancements at a fraction of the ongoing cost.

Using a Managed Backstage: Managed Backstage solutions, such as Roadie or Spotify Portal for Backstage, aim to streamline the adoption of Backstage by offering hosted or SaaS-based implementations. These solutions reduce initial setup effort by handling infrastructure, updates, and maintenance, enabling teams to focus on customization and use cases.

Roadie provides a single-tenant SaaS experience with built-in features like regular updates, SSO, Kubernetes integration, and optional scorecards. Spotify Portal for Backstage takes a similar approach, with an emphasis on simplifying plugin management and reducing the coding burden.

While these solutions address some of the challenges of managing an open-source platform, they often inherit Backstage's core limitations, such as rigid data models that restrict adaptability and a lack of built-in features for ongoing operations. This means that day-to-day workflows, scaling, and evolving requirements still demand significant manual effort. Additionally, these managed offerings may require continuous investment in custom development to align with unique organizational needs, making scalability and long-term cost-effectiveness a concern.

For organizations starting fresh, managed Backstage can mitigate the initial infrastructure burden but may not deliver the broad, out-of-the-box functionality or flexibility required as needs evolve. This raises critical questions about its sustainability compared to alternative developer portals designed for seamless scalability and comprehensive features.

Commercial Solutions

OpsLevel: OpsLevel is designed to help teams manage their microservices with a strong focus on service maturity and compliance. It provides extensive functionality out of the box, allowing teams to achieve faster time-to-value compared to alternatives like Backstage. Key features include a user-friendly interface, maturity scorecards for service ownership, and integrations with popular tools like Datadog and PagerDuty.

However, OpsLevel's approach comes with trade-offs. Its opinionated data model can restrict customization, limiting use cases and making it difficult to adapt to unique organizational workflows. Additionally, while it supports synchronous self-service actions through HTTP webhooks, the lack of workflow automation or API-first development capabilities can increase integration complexity.

OpsLevel also relies on YAML for metadata storage, which can create additional overhead for developers and erode trust in the catalog’s accuracy if not consistently maintained. Furthermore, its Kubernetes catalog lacks visibility into K8s objects, potentially hindering developers unfamiliar with Kubernetes from fully understanding their services.

While OpsLevel offers robust compliance tracking and service maturity tools, these limitations may reduce its flexibility and long-term effectiveness for organizations with evolving needs.

Port: Port takes a low-code approach to developer portals, branding itself as a flexible toolbox for teams to customize and build their own solutions. This flexibility allows users to define their own data models, views, dashboards, catalogs, and menus, making it an adaptable platform for various workflows.

However, this flexibility can also become a double-edged sword. Without clear guidance or guardrails, users risk introducing unnecessary complexity into their configurations. Port operates as a horizontal product, which means users must first identify their use cases and then build the necessary solutions themselves—an approach that demands time, resources, and a clear strategy.

Data collection in Port further adds to user responsibility. While templates exist to help users get started, the platform relies solely on a push-based mechanism, requiring users to implement data pipelines and integrations to feed information into Port’s APIs. This approach shifts the operational burden onto teams, which can be daunting for organizations without sufficient resources or expertise.

While Port’s low-code model and adaptability make it a compelling choice for certain teams, the lack of built-in structure and the heavy reliance on user-driven implementation can limit its accessibility and time-to-value, particularly for smaller teams or those seeking a more guided solution.

Cortex: Cortex positions itself as a compliance-first developer portal, offering robust tools to enforce service standards and provide visibility into dependencies. While it promises a lower total cost of ownership and faster setup compared to Backstage, its limited flexibility and developer-focused features can hinder adoption and long-term usability.

Despite recent efforts to enhance its data model, Cortex relies on fixed entity types (e.g., services, resources, teams) that cannot be fully customized. This rigidity extends to its self-service actions, which lack support for advanced workflows, asynchronous actions, or granular RBAC configurations. For example, Cortex does not allow temporary permissions for on-call engineers or automated ephemeral environments with TTLs.

Its scorecards, a core feature for enforcing standards, are constrained by limited customization options. You can’t trigger automations or detailed workflows based on scorecard results, and evaluation frequencies (every four hours) can delay feedback loops. This undermines its potential as a proactive tool for maintaining service quality.

The platform’s inability to integrate seamlessly with modern Infrastructure-as-Code (IaC) frameworks like Terraform or Pulumi adds further limitations. Developers also face challenges with metadata management, as Cortex relies on basic JSON schemas, preventing dynamic updates or dashboards from reflecting real-time changes. Features like Markdown ingestion, feedback collection, or notifications are notably absent, reducing its utility as a comprehensive developer experience platform.

Finally, Cortex’s limited integrations (e.g., no cost management tools, partial Kubernetes visibility) and lack of extensibility for custom use cases make it less adaptable to complex organizational needs. While it provides foundational compliance features, the absence of real-time updates, customization, and developer-centric capabilities may lead teams to seek more versatile solutions.

Conclusion: Finding Your Fit

The developer portal landscape is evolving, with solutions that cater to different needs and team sizes. Whether you’re looking for flexibility, ease of use, or advanced compliance tracking, there’s an alternative that can elevate your engineering workflows.

Rely.io stands out as a powerful yet lightweight platform that aligns with modern engineering practices. Ready to see it in action? Book a demo today and take the next step toward operational excellence!

Rely.io October 2024 Product Update Roundup

Tiago Barbosa — Thu, 07 Nov 2024 11:02:44 +0000

Welcome to our October update roundup! This month, we focused on making Rely.io more flexible, secure, and insightful. From new integrations to improved dashboards and an enhanced authentication journey, we're excited to share what we've accomplished to bring you more value.

Contextual Filters for More Relevant Dashboards

We know how important it is for you to have the right data at your fingertips.

Dashboards in your Homepage and in your Software Catalog already support User based Dynamic Filters for Related Entities Widgets (for instance, shown in my homepage the list of my on-call team-members).

The contextual filters can now be used within the Table Widgets’ filters and have also been extended to also support both Team and Entity based filters on top of User.

With Relative Filters users can now apply filters on tables using any property available from:

Who they are as the logged in user, using filters like user.email (e.g. to show “my PRs” only)
What team the current user belongs to, using filters like team.title‍
What entity they are currently exploring (only applicable to the Software Catalog), using filters like entity.owner

With our new Relative Filters feature, you can now further personalize your dashboards effortlessly. These filters allow you to add contextual elements, such as user.<property>, team.<property>, or entity.<property>.

Whether you're viewing your own data, looking at your team's progress, or focusing on specific entities, these filters adapt in real-time to your current context, providing a more tailored experience.

Bring visibility to your code quality & security with the SonarQube and Snyk plugins

We're thrilled to announce the release of two new plugins: SonarQube and Snyk.

These integrations bring visibility to code quality and security via the Software Catalog, enabling teams to easily track how the Services they own are performing.

By incorporating SonarQube and Snyk into their workflows, Engineering Leaders not only gain better control over their projects' health but also leverage Scorecards to monitor and increase compliance of their teams and services, ensuring a higher standard of quality and security across your development efforts.

The two plugins are available both as Managed & Self Hosted to fit your deployment requirements.

Troubleshooting Made Easy with Plugin Logs

Ensure your data is properly flowing into the platform is essential to keeping your Software Catalog up to date. The current view of your active plugins already displays a quick summary of their status (active, warning, error).

This month we've made it easier to understand what's happening under the hood with your active plugins.

Their detailed view now includes an additional tab with the actual execution logs from your plugin (whether they are self hosted or managed).

You can now view logs directly in the plugin UI, making troubleshooting faster and more transparent. No more diving deep into configurations or searching through agent logs—you can see what went right or wrong right where you need it.

Enhanced Plugins with APIs Rate Limiting Management in Galaxy

Galaxy, our integration framework, has undergone a significant upgrade this month. We understand that API rate limits can be a real pain point when working with external tools. To address this, Galaxy can now run multiple workers and intelligently shard tasks to respect API rate limits in your integrated systems. This means smoother plugin operations without unexpected slowdowns or interruptions.

Simplified and Secure Authentication with SSO

Your security and convenience are always a priority for us. This month, we've introduced Single Sign-On (SSO) with Okta and Google, making it easier than ever to securely sign up or log in to Rely.io. We've also overhauled our entire authentication flow, ensuring a smooth and secure experience from the first interaction (the invitation, sign up and first log in journeys have all been greatly simplified with reduced steps and clicks).

On the Horizon

Here’s a preview of features coming next:

Engineering Performance Dashboard: Engineering Leaders can review and compare Engineering KPIs across many dimensions (Domains, Teams, Environments) from a single view.‍
Onboarding Wizard for Free Trials: New users will soon benefit from a step-by-step guide, taking them from first login to actionable insights like DORA metrics in under five minutes.‍
Guided Experience for Adding Plugins: Soon, we’ll be bringing the new configuration wizard to the journey for adding new plugins, ensuring every step is clear and efficient there too.‍
Standardized Plugins: Look out for improvements as we standardize more plugins by type (Incident Management, Observability, CI/CD), making integrations even more seamless.

As well as our next incoming Plugins:

FluxCD
ServiceNow
Incident.io
Rootly
Jenkins
Linear

Not a user yet?

If you’re looking for an Internal Developer Portal or are simply interested in trying everything we described here, you can get started for free with Rely.

Want to see Rely in action? Play around in our demo environment, or get your own account here.

Internal Developer Portals: Autonomy, Governance and the Golden Path

Tiago Barbosa — Thu, 31 Oct 2024 13:33:30 +0000

In today’s fast-paced tech landscape, development teams face the challenge of improving their autonomy while adhering to organizational governance. Striking this balance is key for driving innovation and ensuring that teams can focus on what truly matters: delivering high-quality products efficiently.

In this blog post, we’ll explore several key topics that highlight how organizations can empower their developers while maintaining necessary standards. We’ll discuss the importance of team autonomy and how it enhances productivity, the impact of reducing context switching and cognitive overload, and the concept of treating your platform as a product. Additionally, we’ll delve into the significance of standards enforcement and how it contributes to a cohesive development environment.

By the end of this article, you will have a better understanding of some of the most common challenges faced by engineering teams daily, along with effective strategies to overcome them.

Ready? Let’s do this!

What is an Internal Developer Portal in the first place?

An Internal Developer Portal (IDP) is the entry point within an organization for developers to access tools, resources, and documentation they need to effectively build, deploy, and manage applications or services.

The purpose of an IDP is to provide autonomy for developers while at the same time improving governance for organizations through standardization of best practices and access controls. By standardizing best practices and implementing access controls, Internal Developer Portals allow teams to operate independently, all while adhering to essential guardrails that ensure compliance and quality.

While Internal Developer Portals are designed to tackle a variety of challenges for different users, this multifaceted approach can make it difficult to get them just right. Striking the perfect balance between flexibility and structure is key to unlocking their full potential.

We recently released a whitepaper discussing Internal Developer Platforms and Portals, along with key considerations for selecting the right one. If you’re still uncertain about your options, I suggest downloading it here.

This article focuses on identifying and implementing the right balance between providing developers the autonomy they need to be effective in their tasks and at the same time provide relevant insights to the business and teams to improve the way they collaborate and provide value for their customers and stakeholders.

What do developers want from their portal?

Every developer has experienced the endless cycle of new practices, frameworks, processes, and tools that promise to solve the daily challenges they encounter. However, many of these initiatives are often driven by conflicting priorities that don’t always align with the actual needs of software developers. This disconnect can lead to frustration and, over time, result in developers becoming obstacles to new initiatives.

Developers want the freedom to create software without restrictions or relying on other teams. An intuitive Internal Developer Portal will simplify workflows, boost collaboration, and provide easy access to essential resources. It will, not only, enhance productivity but also drive innovation, empowering teams to deliver high-quality software more quickly. In the sections that follow, we’ll dive into some common pain points developers face and explore effective solutions to overcome them.

The dream of fully autonomous teams and individuals

According to a research article published by Microsoft, developers spend approximately 20% to 40% of their time waiting for other teams. This waiting can involve dependencies on infrastructure, approvals, or other teams' tasks, impacting overall productivity, satisfaction and project timelines.

For years, efforts have been put in place with the goal of reducing this number. You have surely heard of DevOps, Platform Engineering, Team Topologies and more. And I bet that most probably your organization follows one of these practices. In a way, all of these have succeeded but also failed because the truth is organizations still struggle to provide autonomy to their teams to reduce the amount of time they spend waiting for others.

But let’s face it, do developers really want to be autonomous or are they just looking forward to having less blockers and being more productive?

Focusing on what is important

In recent years, companies have undergone a radical metamorphosis, embracing digital innovation at an unprecedented pace. According to recent surveys, in 2019, about 30% of companies reported having dedicated budgets for digital transformation. By 2023, this number increased to approximately 70%, showcasing a strong commitment to investing in digital initiatives.

This upward trend underscores the increasing recognition of digital transformation's importance in maintaining competitiveness and has elevated developers to the status of premium assets, with every organization competing for their expertise as they strive to navigate this brave new world.

Simultaneously, developers have assumed greater responsibility for various elements of the software delivery lifecycle. Previously, developers primarily focused on coding while others were responsible for maintaining it. Now, however, most development teams are tasked with building, deploying, and managing the products and features they create in production. If you use AWS or have seen some sessions of their main conferences you have probably heard of “You build it, you run it”.

This can, of course, diminish the need for collaboration. While having diverse skill sets within teams can enhance productivity, it also creates a challenge: developers may become unfocused. As they are required to gain expertise in various areas of the technology stack to deploy and maintain their code in production, their attention can be divided.

You might wonder if this leads to increased productivity for developers. While it can, the key question is whether they are leveraging their expertise effectively. Could the operational aspects of their roles be streamlined so that they can dedicate more time to writing code and delivering new features to customers, thereby maximizing their overall business impact?

Reducing context switching

Every single developer dreams of being focused, without disruptions, when ideas are flowing, time and space fade away, you move with certainty and at a strong pace. This is known as flow state.

When you’re in the flow, you are fully immersed in what you’re doing, and enjoy increased creativity, innovation, and happiness. On the flip side, when developers can’t freely collaborate or get “in the zone”, their productivity suffers. According to a study from the University of California, it takes 23 minutes, on average, to get back into the task at hand after an interruption.

As developers take on more responsibilities, it is crucial for them to learn new skills and adapt to emerging tools and technologies. These tools feature different interfaces, function across various platforms, and fulfill specific roles.

Alongside these technological challenges, developers face additional context-switching activities, such as participating in meetings to share their expertise and ensure team alignment on project goals, or assisting with the onboarding of new team members.

Developers typically waste a significant amount of time due to context switching, with estimates indicating that it can consume between 20-30% of their workweek. A recent survey by Qatalog and Cornell University revealed that 69% of developers report losing 8 or more hours weekly to context switching, which varies across tasks and environments.

This chronic switching negatively impacts productivity and focus, making it a critical issue in software development that needs to be tackled from multiple perspectives as this is more of a people problem than a tool problem.

However, having all the necessary information in one centralized location could greatly improve the situation, wouldn't you agree?

The right skillset

As mentioned before, the demands placed on software developers have shifted dramatically, reflecting a broader transformation in the tech landscape. The concept of shifting left - a pivotal aspect of modern software development - aims to address issues earlier in the development process, enhancing quality and minimizing costs. However, this shift also raises expectations for developers, necessitating a well-rounded skill set that can sometimes exceed practical capabilities.

Shifting left refers to integrating best practices and testing into earlier stages of the software development lifecycle (SDLC) which leads to identifying problems sooner in the process and making them cheaper to an organization than if they were found only in production and affected customers.

This approach makes total sense and it has its benefits for sure but how does this impact development teams?

Cognitive Overload: With the diverse set of technologies and methodologies available, developers face pressure to keep pace, leading to potential burnout and decreased efficiency. It's unrealistic to master every technology in a rapidly evolving field.

Specialization vs. Generalization: While some developers thrive as generalists, others excel in specialized roles. The push for a universal skill set may cause frustration for those who prefer depth over breadth.

Quality vs. Speed: Balancing quality with the need for swift delivery can lead to rushed work, potentially compromising security and reliability. Developers must determine priorities, sometimes at odds with organizational goals.

As organizations continue to emphasize shifting left, it's crucial for companies to recognize the challenges developers face.

What do Platform teams look for in Portals?

For years, Infrastructure teams have been given the responsibility of enforcing standards, yet they often lack the resources and authority needed to truly empower development teams. This disconnect can affect their ability to deliver meaningful value and support.

What these teams truly seek in Internal Developer Portals is the power to eliminate blockers for developers while upholding standards and ensuring compliance. They strive for increased visibility across the organization, which enables smooth workflows and fosters innovation without the hassle of unnecessary friction.

In the following sections, we’ll explore the significant work these teams have accomplished over the years, the challenges they face, and actionable strategies to overcome them.

Building on solid foundations

In the past decade, we've observed a shift where professionals who previously managed in-house servers and infrastructure have transitioned to similar roles in the Cloud. This change required a transition from simple point-and-click operations and local scripts to remote management using Infrastructure as Code (IaC) in a more streamlined and predictable manner.

For many organizations, this has become the new norm. But why does this matter?

The shift to Cloud and Infrastructure as Code (IaC) has compelled teams to reconsider not only their infrastructure but also how these scripts and templates are utilized and their impact on business objectives. Typically, these resources have been made accessible to software developers through various means, such as CI/CD pipelines, command-line interfaces, or sometimes by submitting a ticket to the infrastructure or platform team for execution - commonly referred to as TicketOps.

While some of these methods are more effective than others, they all share a common foundation established by the organization to standardize best practices and simplify processes. This approach aligns with one of the primary objectives of internal developer portals: to enhance the use of existing tools and practices.

Therefore, if you have embarked on this journey over the past few years, you are already ahead of many others.

Platform as product

A significant challenge that operations and infrastructure teams have consistently faced is their perception as gatekeepers and a cost center within organizations. Often viewed as a slower part of the operation, these teams have been seen as obstacles to progress and innovation. However, with the right motivation, strategy, and leadership, this narrative can be transformed.

In recent years, there has been a notable shift where many organizations are establishing internal-focused platform teams. These teams aim to deliver Platform as a Product (PaaP), which encapsulates not only the technical infrastructure but also the necessary tools, services, and support that empower teams across the organization. This approach underscores the importance of these teams as enablers of agility and innovation.

This transition is more than just a rebranding; it represents a strategic pivot towards collaboration, efficiency, and innovation. By treating platforms as products, teams can better understand user needs, enhance service delivery, and promote a culture of continuous improvement. This model encourages cross-functional collaboration, allows for faster deployment of solutions, and ultimately drives business success.

The question now is: What does it mean for organizations? It implies embracing a mindset where operations and infrastructure are not merely support functions but integral components that drive business agility, responsiveness to market changes, and innovation.

In practical terms, this approach means treating your platform like any other product within your organization, with the key distinction being that your customers are internal stakeholders. You will engage with these customers to gather requirements, manage the product backlog and roadmap, and develop the necessary tools and resources for their use. Additionally, you will be responsible for ongoing maintenance and ensuring these solutions are effectively adopted over time.

As a result of this shift, platform teams become powerful enablers, enhancing the effectiveness of various teams while promoting consistent standards across the organization. However, just as companies face challenges in encouraging external customers to utilize their offerings, platform engineering teams may encounter similar difficulties in driving adoption of their platforms.

Improving adoption rates

Increasing user adoption of your Internal Developer Portal can be a significant challenge. As noted in this article, many organizations see Backstage adoption stagnating at just 10%.

Adoption is a crucial aspect of the process, extending beyond just Internal Developer Platforms or customer-facing products. You've done it plenty of times before, potentially in smaller settings. Remember that time you had to persuade your team to follow a new way of testing code, or when you led that project that required a complete redesign? These experiences are directly relevant — they just occur on a larger scale when it comes to product adoption.

Now, here’s a strategy that has consistently worked for me, regardless of the context: keep your “customers” engaged and satisfied. How can you achieve that? Build the features they need to make them more effective.

However, it’s essential to remember that you are developing a product, so manage it accordingly. You’ll be interacting with various teams, each with competing priorities and timelines. Therefore, it’s vital to prioritize effectively and deliver frequently, maximizing the value you provide.

If your teams express frustration over a lack of documentation or find that information is scattered across multiple locations - impacting developer onboarding times - start by implementing Service Catalogs. If they struggle with dependencies on other teams for simple tasks like creating cloud resources, focus on enabling Self-Service actions.

We've seen organizations successfully tackle these in different phases, addressing specific problems and working with smaller subsets of teams. Attempting to solve everything at once is likely to lead to failure.

In short, leverage customer feedback to drive your Internal Developer Portal implementation to ensure higher engagement rates. And while you're at it, why not measure its success?

Enforce standards

Maintaining software in production is no small feat. For those tasked with this responsibility, ensuring that best practices are consistently applied across the entire stack can feel like an uphill battle. In many organizations, the burden of service management often falls to a single team, which simplifies oversight but doesn’t reflect the reality for most teams.

Even if you’re part of a dedicated group that manages the full lifecycle of a product, the landscape changes as your organization grows. Onboarding new team members and ramping up deployment frequency can introduce complexity, and without robust best practices in place from the outset, mistakes are inevitable.

This is where Internal Developer Portals come into play. These powerful tools can streamline your processes in several ways. First, they enable Self-Service actions, allowing developers to scaffold new services that incorporate established patterns across the organization. This not only accelerates development but also ensures that all necessary integrations with observability and incident management tools are seamlessly established, along with the infrastructure needed to run your code.

Moreover, Internal Developer Portals facilitate the automated collection of insights from your services and their dependencies, helping you verify that best practices are being adhered to. This data can be visualized in various formats, such as charts showcasing DORA metrics or team scorecards. Such visibility empowers you to monitor compliance with best practices and make informed, data-driven decisions to enhance both your services and team workflows.

Does it sound like Internal Developer Portals could address many of the challenges you’re currently facing? That’s fantastic!

However, it’s important to remember that achieving the right balance is crucial.

Autonomy vs governance

Improving the developer experience within your organization is not just a possibility; it’s an imperative. However, the timeline for achieving this can vary significantly based on the maturity of your platform and processes - ranging from weeks to months, or even years.

As I highlighted in our earlier discussion about adoption challenges, keeping both developers and platform/infrastructure teams engaged is vital. This means prioritizing the delivery of value frequently. Think of it this way: delivering small, incremental improvements is far more effective than waiting for a massive feature release that could disrupt existing workflows.

If you’re a fan of streaming TV series, you’ve likely experienced the thrill of a new season releasing just a few episodes at a time, with new episodes dropping weekly. The creators don’t release everything at once because they want to keep you engaged and excited for what’s next. The same principle applies here.

By consistently delivering small enhancements, you demonstrate your commitment to improving the developers’ experience. There’s no one who wouldn’t appreciate that!

However, it’s crucial to strike a balance between autonomy and governance. Developers often seek full autonomy, while platform and infrastructure teams prioritize governance. Here’s the reality: autonomy without governance can lead to chaos in the medium term, while strict control without autonomy can hold back creativity and hinder product adoption.

Finding the ‘right’ balance with Golden Paths

Finding the right balance is essential for the successful execution of your Internal Developer Portal strategy. It’s about fostering an environment where developers feel empowered, yet supported by the necessary governance to thrive.

That’s why golden paths are important. Golden paths offer structured guidelines that empower developers to adhere to organizational best practices while still allowing for flexibility to make minor adjustments as needed. By following these golden paths, developers can concentrate on their core tasks without the complexity of navigating compliance issues. For platform teams, golden paths establish a consistent framework that allows them to collect relevant signals that can be used to monitor usage, providing valuable insights and data that help improve practices across the board.

So, you might be wondering how you can do all this in an easy way, right? Let me show you how you can do it in Rely.io.

Default dashboards, views and homepages

One of the primary advantages of Internal Developer Portals is the ability to centralize information in a single location. However, simply gathering information isn’t enough; we need to present it in a way that is intuitive and easy to digest for users.

At Rely.io, we understand this challenge. That’s why we offer out-of-the-box dashboards and views tailored to the most common use cases. This approach enables users to hit the ground running and quickly discover the platform's capabilities. Plus, all dashboards and views are fully customizable to meet your specific needs, utilizing built-in widgets and requiring no coding skills.

Another example of where built-in dashboards provide value immediately is on improving visibility on productivity metrics across your organization. At Rely.io we understand how important this is. If you don’t have enough information on how and where your services are running or how frequently you deploy to production how can you improve?

With Rely.io’s dashboards, you’ll enjoy a seamless experience across various entity types, ensuring standardization throughout your organization while making information readily accessible and actionable.

Self-service actions
At Rely.io we are aware of the time that is spent on repetitive tasks when writing code and maintaining software in multiple environments. This includes, but isn’t limited to, scaffolding new projects, deploying infrastructure, updating feature flags, performing rollbacks, etc.

To overcome this challenge we built the Self-Service Hub which contains a list of relevant built-in actions and allows teams to create their own set of Self-Service actions focused on their needs. In the image below we simplify the steps needed to set up a new project by abstracting everything that happens in the background such as creating a new repo, scaffolding files and folders, creating a new service in the observability and incident management platform, etc.

The execution of Self-Service actions in Rely.io is audited and might require an approval before running which gives developers the autonomy they need within the boundaries and controls implemented by the organization.

Scorecards
A common trend we’ve seen in all our customer engagements is the extensive amount of hours that teams and their leaders spend in collecting data that reflects their current maturity state from a service or production readiness perspective.

They typically depend on data coming from several different platforms that are operated by different teams and since this is mostly for internal use they never invested time and effort into automating these tasks. Well, Rely.io scorecards are here to help.

Scorecards provide an automated and always up-to-date way of collecting insights from several data sources and make them available to everyone. Do you have a service review meeting in 1 week? 1 hour? 5 minutes? We got you covered.

Although this saves teams precious time it doesn’t help with adoption and so we decided to make scorecards fun and engaging by bringing gamification to play. We have been incredibly successful with our leaderboards as it creates some friendly competition between teams and their services. And no one likes to be last, right?

At Rely.io, we’re on a mission to strike the right balance between being opinionated and flexible. Ready to give it a try?

Explore our demo environment or sign up for a 15-day free trial today!

If you’d like to dive deeper into how Rely.io works and discover how it can enhance your developer experience while enforcing standards across your organization, feel free to book some time with our Platform Architects.

Check out our new whitepaper: "Internal Developer Platforms and Portals, a complete overview"

Tiago Barbosa — Thu, 24 Oct 2024 11:11:20 +0000

At Rely.io, we believe that collaboration and learning from our customers are key to building exceptional products. For that reason, we're thrilled to share insights from our latest interactions in a new white paper!

In this comprehensive guide, we’ve compiled valuable lessons and best practices for building a successful developer platform and portal. Whether you're just starting out or looking to enhance your existing setup, this curated resource is designed to help you bring more value to your team by exploring:

What is a developer platform and what are its different parts?
What is a developer portal and why do I need one?
What are it’s benefits?
How can you successfully build one in your organization?

Download now 👇
https://bit.ly/4hmkNtF

How Amplemarket increased their product velocity and drove operational excellence with Rely.io

Tiago Barbosa — Tue, 15 Oct 2024 09:28:09 +0000

Amplemarket is a cutting-edge AI-powered sales platform that helps B2B companies identify and engage with their ideal customers. Founded in 2018, the company has rapidly grown to over 100 employees and serves clients across various industries worldwide.

As Amplemarket scaled its operations, the company faced increasing complexity in managing its software ecosystem and enforcing standardization of best practices. Unwilling to compromise on product quality, Amplemarket needed a robust solution to maintain an accurate inventory of their growing number of services and assets, ensure compliance, and optimize their tech stack.

With the rapid increase in the number of engineers and teams, other challenges emerged: the mounting hours engineers spent unblocking each other, as most information was hard to find and relied on tribal knowledge, Additionally, senior engineers dedicated significant time to supporting new-hire onboarding due to a lack of a centralized knowledge base. This issue required immediate attention.

No more spreadsheets

To keep track of teams, services, and cloud resources, Amplemarket relied on manual spreadsheets, regular multi-team syncs, and audits to monitor the maturity of their software usage and the adoption of engineering quality and reliability standards. This approach was time-consuming, error-prone, and lacked real-time visibility into their software landscape. In many cases, this exercise was a wasted investment since the spreadsheets were rarely consulted—everyone knew they quickly became outdated and offered little value.

Amplemarket knew this wasn’t a long-term solution. Fortunately they found Rely.io.‍

When we started Amplemarket, everything was easily tracked and spreadsheets worked well. However, at our current scale, it's impossible to use spreadsheets effectively. They take too much time to maintain, and nobody really uses them since their information is often outdated.
Tiago Sousa, Head of Engineering at Amplemarket.

Enabling developer autonomy and reducing ticket ops

To enforce standardization and best practices across the organization, Amplemarket created specialized teams responsible for infrastructure deployments and maintenance, CI/CD, coding best practices, business processes, and platform reliability. While this approach improved work quality and enabled consistent practices, these teams often became bottlenecks, slowing down multiple development teams waiting for pending tasks.

Recognizing that their journey was incomplete, Amplemarket realized they needed to enable developer self-service and use the specialized teams' valuable work more efficiently.

At Amplemarket, we're constantly adapting to new and better ways of working. It's the only way we can perform at our best and do more for our customers. With specialized teams, we knew we were taking a step forward—but not reaching our final destination.
Tiago Sousa, Head of Engineering at Amplemarket.

Why did Amplemarket choose Rely.io?

To overcome these challenges, Amplemarket was looking for a SaaS solution that would enable them to:

Improve visibility on services and cloud resources: Gain access to up-to-date information on services built in-house, deployments and the cloud resources that resulted from their deployments to allow for faster problem resolution and more effective cost control.
Optimize new-hire onboarding process: Reduce the dependency on senior employees that centralize most of the knowledge around services and how to operate them to improve their productivity and satisfaction.
Enforce best practices across the organization: Enhance visibility on production readiness and team performance in a way that encourages teams to embrace best practices and defined processes rather than looking at them as a burden.
Reduce developer dependencies and wait times: Enable developer autonomy while paving golden paths that guide them to desired engineering standards, enforcing standardization from day one.‍

Rely.io's software catalog, self-service actions and scorecards capabilities provided Amplemarket with a comprehensive solution that would help them achieve the proposed goals in no time and without much effort due to its opinionated approach and automation capabilities.‍‍

Streamlining Service Management

Amplemarket strategically leveraged Rely.io and its plugins to target services throughout their lifecycle by configuring Git and Cloud providers. Using Rely.io's advanced discovery and mapping capabilities - which follow recommended cloud resource tagging best practices - they centralized all their relevant services, documentation, deployments, environments, and cloud resources in one accessible location.This approach not only improved Amplemarket's visibility into their services but also streamlined the onboarding process for new hires and team members across the organization decreasing the onboarding time and improving employee satisfaction.

Enabling developer autonomy

With Rely.io's self-service capabilities, Amplemarket was able to leverage the work of specialized teams more effectively by turning best practices into self-service actions. Developers can now use these without requiring anyone else's time or attention.Within the self-service hub, they created templates for the services developers can created (e.g. Go microservices, APIs, new Kafka Topic, new cron jobs, and more), provided a catalog of cloud resources developers can create with a couple of clicks and provided one-click deployments and rollbacks to make it easier for developers to ship changes to production with quality gates built into the process.Developers can now deploy and maintain resources they're accountable for while effortlessly following organizational standards. For high-impact actions (such as those exceeding company-defined cost thresholds or production deployments), an approval mechanism ensures users can't perform tasks alone that require collaboration or higher-level approval.

Tracking and enforcing best practices

With Rely.io’s built-in scorecards, Amplemarket was able to quickly identify areas where they had to improve from a production readiness perspective which allowed them to prioritize their actions based on concrete up-to-date information.‍ Amplemarket leveraged leaderboards to foster healthy competition amongst teams, challenging them to rank first in scorecards like Service Production Readiness and DORA metrics. This initiative not only engaged teams in a productive and fun activity but also enhanced Amplemarket's ability to deliver high-quality products to their customers. After all, no one likes to be last!

Amplemarket’s favorite feature

A feature we now love, but didn't initially value much, is 'Discovery'. Like any fast-growing company, we have numerous experiments, old projects, and repositories. The ability to choose which resources end up in the Software catalog is a time-saver and a great experience for anyone maintaining the platform.
Tiago Sousa, Head of Engineering at Amplemarket.

When users configure any plugin in Rely.io, it triggers a discovery process to collect information from the source. Once collected, all new entities are listed on the "Discovery" page, where users can accept or ignore their creation.

This process gives users more control over which entities are relevant enough to import into the catalog. It's particularly valuable for Git providers, as customers don't want to clutter their software catalog with non-relevant projects or demo environments that could negatively impact their scorecards.

Future goals with Rely.io

Moving forward, we want to explore Scorecards in more depth and create new ones to track our own business metrics. Additionally, we'll extend our use of Self-Service Actions to allow developers to do more than creating new projects and deploying infrastructure resources. This continued investment in standardizing our approach will allow us to reduce bottlenecks even further, allowing developers to focus on what's truly important: building new features and delivering more value to our customers faster.
Tiago Sousa, Head of Engineering at Amplemarket.

By working with Rely.io, Amplemarket achieved quick wins that had a real business impact on their product reliability. It also improved the onboarding process for new hires, resulting in increased employee engagement and satisfaction.

We're excited to see what's next. Thank you for trusting Rely.io!

Rely.io September 2024 Product Update Roundup

Tiago Barbosa — Tue, 15 Oct 2024 09:15:19 +0000

This September, we’ve delivered several enhancements focused on simplifying onboarding, increasing transparency, and improving the out-of-the-box value of our platform. Whether you're exploring Rely.io for the first time or a long-time user, these updates aim to make your experience smoother and more productive.

Free Trial: Start Your Journey Toward Better Developer Experience and Performance

We’re excited to offer a 15-day free trial of Rely.io, allowing you to explore how our platform can transform your developer experience and boost engineering performance. During the trial, you’ll have access to all of Rely.io’s core features, designed to deliver immediate value:

Software Catalog: Gain complete visibility into your services and systems, with a constantly updated catalog that integrates directly with your development tools. No more stale documents or scattered information—find everything in one place.
Self Service: Empower your developers to take operational actions, such as scaffolding new services, without relying on manual processes. This keeps best practices and security measures in place while improving efficiency.
Scorecards: Set measurable goals, such as increasing deployment frequency or improving security standards, and track your progress automatically using metrics like DORA. This helps your teams continuously improve their performance and compliance with company standards.
Homepages: Tailor your dashboards to focus on what matters most to you, with customizable views that aggregate your key data, from pull requests to incidents, all in one place.

During the free trial, you won’t be left on your own. We provide best-effort support to ensure you get the most out of your trial and can experience the full benefits of Rely.io. For more details, check out our full announcement here.

Please note that free trial accounts come with just one limitation: you can only add Git plugins at this time. However, this still allows you to explore key features and see how Rely.io can streamline your development processes.

Self-Service Onboarding Wizard: Get Set Up in Under 5 Minutes

Setting up the Self-Service Agent has just gotten easier with our new onboarding wizard, designed to help users get up and running in under five minutes.

This step-by-step guide ensures that each setup action is completed correctly by validating each step in real time, such as confirming the Agent’s heartbeat to verify it is operational before proceeding.

For advanced users who prefer more control, you can still skip the onboarding and achieve the same results by following our detailed documentation here.

Currently, the wizard supports Agent deployment via Helm chart, but we’ll soon be adding support for Docker deployments, making it even more flexible to match your preferred setup method.

This intuitive experience not only saves time but also reduces the likelihood of setup errors, ensuring a smoother path to realizing the benefits of Self Service for your teams.
Once the agent is successfully set up, users can enjoy Self Service actions and increase Engineering autonomy and productivity.
But what happens if the agent encounters an issue and actions cannot be run anymore?
Our platform can now detect agent failures and while users can still create actions and add them to the agent’s queue to be run, they are clearly notified the agent is not properly responding and needs attending to.

Stay tuned, as we’ll be expanding this wizard to improve other workflows, like adding plugins.

Action Approval: Frictionless Control for Critical Self-Service Operations

Self-Service Actions eliminate the delays and frustration of traditional TicketOps workflows, allowing developers to move quickly and autonomously.
However, for critical operations—such as scaffolding new services, provisioning costly cloud resources, or granting temporary access to secure systems—having control mechanisms in place is essential.
Our Action Approval system ensures that developers can still move fast while giving Platform Engineers a frictionless way to validate and approve these sensitive actions.
When an action requires approval, the system adapts the experience for developers by changing the call-to-action from [Run] to [Submit], making it clear that additional approval is needed.
However, in the past, developers had limited visibility into the approval process—such as who would be reviewing their submitted actions.

That’s now changed. We’ve introduced a new section in the action submission form, which clearly outlines who can approve each action, giving developers full transparency into the next steps of the process. This improvement adds clarity while maintaining the fast-paced efficiency that Self-Service is designed to deliver.

Standardized Integrations for Consistent Catalogs

We’ve standardized key concepts across our integrations to deliver a more consistent and valuable Software Catalog out-of-the-box. Tools like Git providers often implement similar features (e.g., Deployments, Environments) differently. With this update, Rely.io now standardizes how these core concepts are imported into your catalog, ensuring a unified experience across different platforms. This means less manual adjustment and more immediate value, no matter what tools you use.

On the Horizon

Here’s a preview of features coming next:

Guided Experience for Adding Plugins: Soon, we’ll be bringing the new configuration wizard to the journey for adding new plugins, ensuring every step is clear and efficient there too.
Onboarding Wizard for Free Trials: New users will soon benefit from a step-by-step guide, taking them from first login to actionable insights like DORA metrics in under five minutes.
Enterprise SSO Support: We’re adding support for OIDC and SAML for secure, enterprise-grade Single Sign-On (SSO).
Standardized Plugins: Look out for improvements as we standardize more plugins by type (Incident Management, Observability, CI/CD), making integrations even more seamless.

As well as our next incoming Plugins:

FluxCD
ServiceNow
Incident.io
Rootly
Jenkins
Linear

Not a user yet?

If you’re looking for an Internal Developer Portal or are simply interested in trying everything we described here, you can get started for free with Rely.
Want to see Rely in action? Play around in our demo environment, or get your own account here.

15-day free trial available...now!

Tiago Barbosa — Sat, 21 Sep 2024 21:50:48 +0000

Why We Are Releasing a Free Trial Plan

In recent months, we've been working closely with our customers. We learned that while a fully populated demo environment is great for a first glance at the product and its capabilities, our customers want more—they desire a full-fidelity experience.

We listened, and we delivered. 🎉

The 15-day free trial is now available to everyone. No credit card. No fees. Just sign up and embark on a journey that will improve the way your organization works by focusing on what really matters. We'll take care of the rest.

What's Available in the Free Trial

We've chosen to release the free trial plan with all the features of our Pro and Enterprise plans, except for some plugins that are currently exclusive to those tiers.

Don't worry, though. You'll have access to all our supported Git providers (GitHub, GitLab, and BitBucket). And we have a few more on the way.

How to get started

To get started, visit our website at https://rely.io and click on "Start free trial".

You'll be redirected to the Rely.io console at https://webapp.rely.io. Once there, sign up by providing your email address, name, and password.

After successfully signing up, you'll receive an email to activate your account. Click the link in that email to confirm your account.

Once your account is confirmed, set up your organization in Rely.io and add yourself to a team.

And that's it. Your account is ready! Don't believe me? Just head over to https://rely.io and sign up yourself.

If you have any questions or need help setting up Rely.io for your specific use case, simply reach out to our Platform Architects.