Software Engineer Go

About this role

The challenge
We are looking for a Mid-Level Software Engineer (Go) to help build and scale the software layer behind Plenit’s cloud platform.

Plenit is growing both in product surface and technical complexity. Our platform connects infrastructure, automation, partner workflows, provisioning, billing, APIs, and customer-facing services across multiple countries and thousands of workloads.

As we scale, we need engineers who can build reliable backend systems that remain simple to operate, easy to evolve, and resilient under increasing load.

You will join a multidisciplinary engineering team responsible for designing, building, and maintaining the services that power Plenit’s platform.

Go is becoming an increasingly important part of our backend architecture, particularly for services where performance, concurrency, scalability, and operational simplicity matter.

This is not a role where you will only implement tickets.

You will be expected to understand the problem behind the feature, participate in technical decisions, challenge assumptions, design solutions, and take responsibility for what you put into production.

You will work closely with Software Engineering, Infrastructure, Product, UX, and other technical teams to solve problems that often sit between application software and real cloud infrastructure.

You should be comfortable reasoning about APIs, distributed systems, asynchronous workflows, databases, observability, failures, and production behaviour.

And most importantly, you should care about building software that keeps working when the easy assumptions stop being true.


Expected outcomes and impact

• Design, develop, and maintain backend services and APIs primarily using Go.
• Build reliable software that supports Plenit’s cloud services, internal platform capabilities, and partner-facing products.
• Design scalable and maintainable services capable of supporting increasing volumes of users, workloads, devices, and infrastructure operations.
• Work on systems involving provisioning, orchestration, automation, lifecycle management, integrations, and asynchronous workflows.
• Design clear and stable APIs that can be safely consumed by other Plenit services, frontend applications, partners, and third-party integrations.
• Participate in architectural and technical design decisions, balancing scalability, maintainability, delivery speed, and operational complexity.
• Design efficient data models and access patterns using relational databases and other storage technologies where appropriate.
• Work with event-driven architectures, message queues, background processing, and distributed workflows.
• Build software with production reliability in mind, including graceful failure handling, retries, idempotency, timeouts, concurrency, and observability.
• Write maintainable, well-tested code and contribute to strong engineering standards around testing, code reviews, documentation, and deployment.
• Investigate production incidents, identify root causes, and implement improvements that prevent recurring issues.
• Improve the performance and reliability of existing services as the platform scales.
• Contribute to the migration and evolution of parts of our existing platform architecture toward Go-based services where it provides clear value.
• Work closely with Infrastructure teams to understand the real systems our software controls and avoid building abstractions disconnected from operational reality.
• Collaborate with Product and Engineering leads to turn business and partner problems into technically sound solutions.
• Participate actively in code reviews, technical discussions, engineering planning, and continuous improvement initiatives.
• Help simplify our architecture wherever possible. We prefer understandable systems over unnecessary sophistication.
• Own the software you build through its full lifecycle: design, development, testing, deployment, observability, maintenance, and evolution.

Requirements that are important for us

Basic Qualifications

• 3+ years of professional software engineering experience.
• Strong professional experience developing production systems with Go (Golang).
• Strong understanding of Go fundamentals, including concurrency, goroutines, channels, interfaces, error handling, context management, and memory considerations.
• Experience designing and building backend services in distributed or service-oriented architectures.
• Strong understanding of and practical experience applying Hexagonal Architecture (Ports and Adapters), including clear separation between domain, application, and infrastructure layers, dependency inversion, and dependency injection.
• Strong experience building and consuming REST APIs and working with API-first systems.
• Experience with relational databases such as PostgreSQL, MySQL, or similar technologies.
• Good understanding of database design, indexing, transactions, consistency, and performance.
• Experience working with asynchronous processing, event-driven architectures, message queues, or distributed workflows.
• Strong understanding of software engineering fundamentals including testing, clean code, maintainability, version control, and code review.
• Experience working with containerized applications using Docker.
• Familiarity with CI/CD pipelines and automated software delivery.
• Comfortable using AI-assisted development tools as part of daily engineering work, while critically validating generated output and maintaining responsibility for security, privacy, testing, and code quality.
• Experience debugging production systems and performing root-cause analysis.
• Comfortable working with logs, metrics, traces, dashboards, and monitoring systems.
• Understanding of common distributed-system challenges such as partial failures, retries, idempotency, race conditions, timeouts, and eventual consistency.
• Experience working collaboratively with Engineering, Infrastructure, Product, or Platform teams.
• Ability to communicate technical decisions clearly and challenge solutions constructively.

Nice to have

• Previous experience building software for cloud providers, infrastructure platforms, hosting companies, developer platforms, or similar technical environments.
• Strong knowledge of cloud infrastructure concepts including compute, networking, storage, virtualization, provisioning, or orchestration.
• Experience with Kubernetes and container orchestration.
• Experience with gRPC and Protocol Buffers.
• Experience with RabbitMQ, Redis Streams, or similar messaging technologies.
• Experience building high-throughput or highly concurrent systems in Go.
• Experience working with microservices at meaningful production scale.
• Experience with observability stacks such as Prometheus, Grafana, VictoriaMetrics, VictoriaLogs, Elasticsearch, OpenTelemetry, or similar technologies.
• Experience with Redis or other caching technologies.
• Experience with public or private cloud technologies such as AWS, Azure, GCP, OpenStack, VMware, Proxmox, KVM, or similar platforms.
• Knowledge of networking fundamentals including HTTP, DNS, TCP/IP, proxies, load balancing, and service communication.
• Experience modernizing or decomposing legacy applications into independently deployable services.
• Previous professional experience with PHP and Symfony is valuable, particularly for engineers comfortable working across an evolving codebase.
• Experience contributing to architectural decisions or mentoring other engineers.

Why Plenit
At Plenit, software does not live in isolation from infrastructure.
The code you build interacts with real compute, storage, networking, provisioning systems, automation workflows, and partner operations across our cloud platform.
That creates engineering problems that are more interesting than simply adding another endpoint to another SaaS application.
You will work with a team that values technical ownership, pragmatic architecture, simplicity, and engineers who want to understand the systems they are building rather than only the code assigned to them.
You will have the opportunity to shape how Go is used across the platform, influence architectural decisions, and build services that directly support the next stage of Plenit’s growth.
If you enjoy building distributed systems, care about production quality, and like working close to the infrastructure your software controls, we’d love to talk.