Port x Amplication: Announcing a new integration

March 24, 2025

Ready to start?

Port x Amplication: Announcing a new integration

We’re happy to announce a powerful new integration between Port and Amplication. This integration allows platform and engineering teams to quickly create, manage, and standardize services while tracking technical debt in real time, using Amplication’s automated backend service creation with Port’s internal developer portal (IDP) governance and self-service actions.

We’re also excited that the Amplication team used our Ocean open source extensibility framework to create and deliver this integration. Ocean greatly simplifies the process of writing a new integration for Port — your only requirement as a developer is to implement the logic that will query your desired third-party system. Ocean then provides abstractions and other commonly required functionality to interact with Port's REST API. 

We’re excited to have partners building and delivering these integrations and helping us to improve Ocean as a community-driven effort. Port encourages members of our community to contribute their own integrations, as well as improve existing integrations and the core of the Ocean framework itself.

Why this integration matters

One of the top use cases for Port and internal developer portals is to streamline service creation, while also maintaining and enforcing your standards and best practices. Engineering teams want to move fast, but also make sure everything is stable and avoid the need to rework things later. With Amplication and Port working together, teams can:

  • Create backend services effortlessly using pre-configured templates.
  • View and manage services at an individual, team, and organization levels centrally within Port.
  • Monitor and act on technical debt to ensure long-term maintainability.
Amplication dashboard in Port

How it works

1. Rapid service creation with pre-built templates

Developers don’t need to know all the ins and outs of defining backend services or attempt to manually follow the team or company standards. Instead, Amplication's integration allows your platform engineers to manage service templates, which can then be used directly within Port. These templates include:

  • Pre-configured architectures
  • Best practices and company standards baked into the service structure
  • Automated setup for APIs, databases, and authentication

When a new service is needed, developers can simply select a template within Port, and use a self-service action to deploy via Amplication, reducing setup time and ensuring consistency across the organization.

2. Seamless management and governance in Port

Port is the central source of truth for software, services, APIs, and more, which includes all services created with Amplication. Keeping up with this information across large, distributed engineering groups is next to impossible manually, without automations and integrations throughout the SDLC, and Port provides these connections. Teams gain visibility into all their services, including metadata such as:

  • Service descriptions
  • URLs and dependencies
  • Ownership details

By integrating Port’s governance capabilities, platform teams can standardize the development lifecycle, making it easier to maintain large-scale infrastructures. Collaboration is also much easier when teams can find others in the organization who may be working on similar projects and can easily find service details and owners. 

3. Avoiding technical debt and noisy alerts

A key benefit of Amplication’s integration is proactive technical debt monitoring and template updates. Let’s face it, there are many instances where services and resources are deployed, and then they sit. Best practices and standards change; deployed services drift over time. Before you know it, it’s a nightmare to realign deployed systems with the latest standards. Amplication is a huge help here! 

  • Platform teams can update service templates with new technology, improved dependencies, or updated best practices.
  • When a new version of a template is released, owning teams receive a notification about the update. 
  • The owning team can then request a pull request to automatically update their service with the latest improvements.
  • Port can bring all your developers’ updates and changes into one central view, so they don’t have to hop from tool to tool to stay on top of the latest updates.
  • This ensures that all services remain aligned with the latest standards, while giving teams control over when and how updates are applied.
  • With Port, you can create scorecards that align with the latest best practices defined in Amplication, further ensuring engineers are clear what is expected and how they stack up.

Amplication and Port ensure all your services stay up to date with modern technologies and security updates, reducing the burden of tech debt accumulation by making updates manageable and incremental. Give developers autonomy while allowing platform teams to enforce best practices.

You can learn more about the integration in the Port documentation and on Amplication’s blog.

What’s next?

We’re excited to be working with the Amplication team and further expanding the use cases we have together. We have some great ideas, like allowing developers to modify existing services through Port, and introducing deeper analytics and insights to enhance service observability. 

We’d love to hear your ideas, too! Share your thoughts with us on our public roadmap.

Get started today

If you're already using Amplication and Port, this integration is available now. Start creating standardized backend services effortlessly while maintaining full control over your infrastructure.

For detailed setup instructions, check out our documentation on Amplication.

{{cta-demo-baner}}

{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical walkthrough of Port

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta-demo}}
{{reading-box-backstage-vs-port}}
{{cta-backstage-docs-button}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Starting with Port is simple, fast and free.

Let’s start