Talent network
Join the Kuneo
network.
We build teams around real work, so we like to meet strong senior people before the right engagement appears.
If you are experienced, communicative and comfortable owning your work, introduce yourself.
What every profile expects
The profiles below are capabilities we regularly look for. They are not necessarily open positions today.
- 6+ Senior experience. Usually 6+ years, but depth and judgment matter more than a number.
- Remote No office requirement.
- English Working proficiency, written and spoken
- AI tooling Comfortable using modern AI tools responsibly as part of day-to-day work.
Profiles
No profiles match your search.
Try a broader term or another category.
Engineering
Backend, frontend and full-stack builders who own their work end to end.
-
Backend Engineer (.NET + Azure)
Design and ship backend services in C#/.NET on Azure, owning APIs, data models and integrations end to end.
What we look for
What we look for
- Deep C# and ASP.NET Core, proven in production
- REST API design: versioning, contracts, error handling
- Azure: App Service or Functions, SQL or Cosmos, CI/CD pipelines
- Relational data modeling and query performance
-
Backend Engineer (Node.js + AWS)
Build Node/TypeScript services on AWS, from API design through deployment and production support.
What we look for
What we look for
- Strong Node.js and TypeScript in production services
- AWS: Lambda, API Gateway, DynamoDB or RDS, SQS/SNS
- Asynchronous patterns, idempotency and failure handling
- Test coverage you would defend in review
-
Backend Engineer (Python)
Develop Python services and integrations, with an emphasis on clean data access and reliable APIs.
What we look for
What we look for
- Strong Python (FastAPI, Django or Flask) in production
- PostgreSQL: schema design, indexing, migrations
- Integration work: third-party APIs, auth, webhooks
- Comfortable owning a service from design to on-call
-
Backend Engineer (Java + Spring)
Build and evolve Java services with Spring Boot across API contracts, data access and deployment.
What we look for
What we look for
- Modern Java (17+) and Spring Boot in production services
- Service boundaries, messaging (Kafka or RabbitMQ) and resilience patterns
- JPA or Hibernate with a close eye on the SQL it generates
- Automated tests at unit, integration and contract level
-
Frontend Developer (Angular)
Build Angular applications with the kind of structure and state discipline that survives being handed to another team.
What we look for
What we look for
- Angular (current versions) and TypeScript in production apps
- RxJS and reactive state you can explain and debug
- Accessibility: semantic markup, focus, keyboard paths
- Performance work: bundle size, rendering, Core Web Vitals
-
Full Stack Engineer (Express + Node + Frontend)
Work across the stack on product features, with Express/Node services on one side and the interface on the other.
What we look for
What we look for
- Comfortable in both a Node/Express backend and a modern frontend
- TypeScript across the boundary, shared types where they help
- Auth, sessions and secure handling of user data
- Able to own a feature end to end without handoffs
-
Full Stack Engineer (Next.js + TypeScript)
Build web products in Next.js across server rendering, API routes and the interface itself.
What we look for
What we look for
- Next.js and React in production with server and client components
- Typed data contracts shared between server and client
- Rendering strategy chosen per page: static, server or client
- Web performance and accessibility checked before every release
-
Frontend Engineer (React)
Build React interfaces, often the first thing a client sees, with the polish that implies.
What we look for
What we look for
- React and TypeScript in production applications
- Reusable components and design systems
- Accessibility and responsive layout from the first commit
- Testing: unit plus at least one end-to-end approach
-
Mobile Engineer (iOS)
Build iOS applications that hold up in the field: offline, interrupted and on real devices.
What we look for
What we look for
- Swift and SwiftUI (or UIKit) shipped to the App Store
- Local persistence and offline-first sync patterns
- Device constraints: memory, battery, poor connectivity
- Release process: provisioning, review, staged rollout
-
Mobile Engineer (Android)
Build Android applications that stay responsive on real devices and unreliable networks.
What we look for
What we look for
- Kotlin and Jetpack Compose (or Views) shipped to Google Play
- Coroutines and Flow used with a clear threading model
- Local persistence with Room and offline-first sync patterns
- Release process: signing, staged rollout, crash monitoring
-
Mobile Engineer (React Native)
Build cross-platform mobile apps in React Native that feel native on both iOS and Android.
What we look for
What we look for
- React Native and TypeScript in apps live on both stores
- Native modules or bridging work when the framework runs out
- Performance on mid-range devices: lists, startup time, memory
- Release pipelines for both platforms and over-the-air updates
-
Software Architect
Own technical direction across a workstream: the decisions that are expensive to reverse, and the reasoning behind them.
What we look for
What we look for
- Have designed and shipped systems that outlived your involvement
- Able to weigh trade-offs in writing and defend them to builders
- Cloud architecture at real scale, with cost and failure in mind
- Comfortable saying no, and explaining why
Cloud & platform
The people who make environments repeatable, observable and safe.
-
DevOps Engineer
Make delivery boring: reproducible environments, automated pipelines, and visibility when something goes wrong.
What we look for
What we look for
- Infrastructure as code (Terraform, Pulumi or CloudFormation) at scale
- CI/CD pipelines you designed and built
- Kubernetes or a comparable container platform in production
- Observability: metrics, logs, traces, alerting that people trust
-
Platform Engineer
Build the internal platform that product teams deploy on and make the safe path the easiest one to take.
What we look for
What we look for
- Kubernetes platform design: multi-tenancy, networking, upgrades
- Infrastructure as code with reusable modules and policy checks
- Self-service templates and golden paths that teams adopt willingly
- Platform metrics such as lead time, deployment frequency and cost
-
DevSecOps Engineer
Put security checks in the pipeline that developers leave switched on.
What we look for
What we look for
- Security controls automated into build and deploy
- Dependency, secret and container scanning wired into CI
- Threat modeling done early enough to shape the design
- Cloud IAM done properly: least privilege, auditable
-
Site Reliability Engineer
Keep production honest: define what good looks like, measure it, and fix the system when it drifts.
What we look for
What we look for
- SLOs and error budgets used to make real decisions
- Production incident response, including the writing afterwards
- Capacity, load and failure testing you designed
- Automation of the toil you found
-
Cloud Security Engineer
Own cloud security posture across accounts, identities and data paths for systems handling sensitive information.
What we look for
What we look for
- Cloud security architecture across AWS or Azure at scale
- Identity and access design: roles, policies, federation
- Detection and response for cloud-native workloads
- Compliance contexts (SOC 2, ISO 27001 or similar) worked through
-
Application Security Engineer
Help engineering teams find and fix security weaknesses in the code they write and the libraries they use.
What we look for
What we look for
- Secure code review across at least two mainstream languages
- OWASP Top 10 and ASVS applied to real applications
- SAST, DAST and dependency scanning tuned to keep false positives low
- Remediation guidance that developers can act on
Data & AI
Data platforms, pipelines and applied machine learning.
-
Data Engineer
Build the pipelines and models other people depend on, where correctness matters more than speed of delivery.
What we look for
What we look for
- Advanced SQL and dimensional modeling
- Python for ingestion, transformation and orchestration
- Batch and streaming pipelines with real failure handling
- Warehouse or lakehouse platforms (Snowflake, BigQuery, Databricks)
-
Database Engineer
Keep production databases fast, recoverable and well designed as data volumes grow.
What we look for
What we look for
- Deep PostgreSQL or SQL Server administration in production
- Query and index tuning based on execution plans
- Backup, restore and replication tested before they were needed
- Schema migrations planned for minimal downtime
-
AI Engineer (Machine Learning)
Take models from notebook to production, including the parts nobody enjoys: evaluation, monitoring and drift.
What we look for
What we look for
- ML in production: training, serving, versioning, monitoring
- Strong Python and the standard ecosystem
- LLM application work: retrieval, evaluation, prompt systems
- Able to explain model limits to non-specialists honestly
-
MLOps Engineer
Build the pipelines and infrastructure that move models from experiment to a monitored production service.
What we look for
What we look for
- ML pipelines for training, evaluation and deployment (MLflow, Kubeflow or similar)
- Model serving with versioning, rollback and resource limits
- Monitoring for data drift, model quality and inference cost
- Strong Python plus containers and CI/CD
-
Data Analyst
Turn questions into evidence, then turn that evidence into something a decision-maker can actually use.
What we look for
What we look for
- Advanced SQL against real, messy data
- Dashboard and reporting work that people actually open
- Statistical literacy: what a result does and does not support
- Able to push back on a badly framed question
Leadership & delivery
People who carry the work: direction, quality and the client relationship.
-
QA Engineer
Treat quality as engineering work from the first sprint.
What we look for
What we look for
- Test automation frameworks you designed and maintain
- API, integration and end-to-end testing strategy
- Testing wired into CI, with results nobody has to chase
- Able to argue for quality without becoming the blocker
-
QA Automation Engineer (SDET)
Write and maintain the automated test suites that let a team release with confidence.
What we look for
What we look for
- Automation frameworks in code (Playwright, Cypress, Selenium or similar)
- Solid programming skills in TypeScript, Java or Python
- Contract, API and performance tests running in CI
- Flaky-test diagnosis and test data management
-
Business Analyst
Turn an ambiguous business need into something a team can build against without guessing.
What we look for
What we look for
- Requirements elicitation with stakeholders who disagree
- Process mapping and gap analysis on real systems
- Specifications engineers read voluntarily
- Able to hold a scope without becoming rigid
-
Delivery Manager
Carry delivery for a workstream: the plan, the risks, and the conversation with the client.
What we look for
What we look for
- Delivered software workstreams end to end
- Planning and estimation that survived contact with reality
- Client communication: expectations set early and honestly
- Raises risks early, while there is still time to act
-
Business Development Manager
Open and grow Kuneo’s partner and client relationships.
What we look for
What we look for
- Technology services or staffing business development
- Partner and channel relationships built from cold
- Commercial judgement: shaping a deal that can be delivered
- Able to represent technical work credibly to a technical buyer
-
Development Manager
Lead engineers as people and as a practice: growth, standards, staffing and the quality of what ships.
What we look for
What we look for
- Managed engineers, including performance conversations
- Technical judgement strong enough to earn their respect
- Hiring: defining the bar and holding it
- Balanced people and delivery without dropping either
-
Project Manager
Keep multi-track work moving: dependencies visible, risks named, communication predictable.
What we look for
What we look for
- Managed concurrent workstreams with real dependencies
- Risk and issue management done before it is a fire
- Status communication people can trust at a glance
- Comfortable with technical detail without pretending to be an engineer
-
Scrum Master
Coach delivery teams through planning, review and retrospectives so that each sprint improves on the last.
What we look for
What we look for
- Scrum or Kanban practiced with engineering teams that ship software
- Facilitation of planning, review and retrospectives that lead to action
- Flow metrics used to spot bottlenecks early
- Able to remove impediments across team and client boundaries
-
Technical Lead (.NET)
Lead a .NET team technically: set the patterns, review the work, and stay hands-on enough to be credible.
What we look for
What we look for
- Deep .NET/C# with architecture-level ownership
- Has led engineers through design and code decisions
- Code reviews that explain the reason behind each change
- Still writing code you would put your name on
-
Technical Lead (Frontend)
Lead frontend work across projects: the architecture, the standards, and the people building against them.
What we look for
What we look for
- Deep React and/or Angular with architecture-level ownership
- Design-system and component architecture experience
- Led frontend engineers technically
- Performance and accessibility as standing requirements
How to apply
Tell us what you have built.
Send a short note, your CV and the work you are proudest of. Tell us which profile fits you best. There may not be an active engagement today. The point is to know each other before the right one appears.