The world of technology is changing fast, and we’re working hard to keep up. Read this article to see what technologies we’re currently working with, the methodology of our team members, the metrics we use to evaluate our work, and more.

Every day we have roughly 250+ engineers developing Wrike. We create new features, optimize existing ones, and take care of the quality of the code. Here we’ll explore the structure of our R&D department, our engineering culture, and values.

Work at Wrike

How we work

A grid showing the process of taking a Wrike task to deployment

Product engineering

Our units consist of two to four Scrum teams that work on product verticals. These cross-functional teams connect Wrikers from different functions: product, UX, analytics, and engineering (backend and frontend developers, QA and automation engineers). Some specialists may contribute to the success of several teams at once. The team’s scope also may change depending on the company’s goal.

For example, the Core Experience unit’s mission is to help our customers get things done efficiently by structuring and providing quick access to work through delightful experiences. To follow this mission, the unit focuses on the base product: the scope of Wrike functionality that all Wrike users experience every working day, regardless of their job roles or company specifics. This includes general UX; navigation; content structuring and organisation; work creation; main product views like hierarchical tables, Kanban boards, and Gantt charts; custom field theming, and messaging; collaboration, and much more.

How do we prioritize and set goals for our teams?

The product manager typically shares their vision for a feature based on the company’s product goals. Then, the team discusses corner cases and creates a high-level plan to roll out this feature, including its fit into Wrike’s overall architecture and other product tracks.

We believe that only an engineer who fully understands the needs of the business can work out, plan, and implement a feature in the best possible way. All of our engineers take part in the decision making process for anything that goes out to our customers.

Internal engineering

Internal teams provide the tools and features that speed up the development process, ensuring the flexibility of the system in terms of using technology stacks and guaranteeing that the code base is stable and up to our quality standards. Engineers on technical teams develop tooling, improve the platform and the quality of the code, and work on shared libraries (e.g., our UI Kit) as well as devtools.

The main projects of internal teams are:

  • Tools and metrics for controlling the quality and stability of code during development and production
  • A library of visual components (UI Kit)
  • Core mechanics of the client architecture (e.g., independent applications, routing, and transports)
  • Improving the accessibility of the product

Engineering departments


Frontend engineers at Wrike are engineers first and foremost. They solve problems using solutions, which often don’t lie on the surface. They deal with bugs in the framework as well as in the language parser. If they’re unable to find a suitable solution on the market, they can always independently make a proprietary low-level library for their needs (for example, they have their own complex Gantt component).

UI Kit: We use a standardized component library (UI Kit) with documentation and API, which has over 150 components for quick interface creation. If it’s not enough, together with the UI Kit team, you can develop your own component according to all the canons of UX/A11Y design. The UI Kit functions as a fully fledged separate team and consists of UX designers, frontend developers, UI developers, and QA engineers.

Metrics: We appreciate metrics and constantly collect data on assemblies, component usage, tests, quality, and amount of code. Internal unit teams help product teams to accelerate development. They collect feedback from developers and designers, analyze data, identify problems and their causes, and prototype solutions. After such research, we decide how we’ll proceed and roll out the update to the entire company.

Going beyond the team and the unit, proactive engineers can deal with the quarterly goals of the frontend department and even participate in setting those goals; this is a huge chunk of work to improve the architecture, frontend infrastructure, and processes within the department.

Stack: The main part is a combination of TypeScript and React, but we also have some old components based on Dart and AngularDart. We have micro-frontend architecture, so we’re developing new parts of the product as independent applications. Each application is delivered to users within minutes. If something doesn’t go according to plan, we can roll back the changes in 10 seconds.


Being responsible for the backend in Wrike means being responsible for the most valuable things a company has: customer data, app performance, and service availability.

We invest in our architecture and it gives results. We deploy daily and rarely encounter merge conflicts despite working with a distributed monolith (this has historically become a thing).

To give teams the flexibility to work and instill a sense of ownership of their features, we’re moving towards a microservice architecture. Product teams are supported by technical teams to help them implement new functionality in individual services.

Engineers can vary their work and not get stuck in one area. Developers from product teams can invest in the technical foundation of the backend and conduct research. We also have the opportunity to influence product tasks; before planning, product owners (POs) consult with engineers and listen to ideas and suggestions from colleagues.

Main stack: Java 17, Spring, PostgreSQL, and MyBatis

Messaging: Kafka, RabbitMQ, and Redis

CI/CD: Maven, TeamCity, and GitLab CI (for new modules)

We are open to adopting specific technologies as needed, like Snowflake. We strive to use a modern stack but also develop our own tooling, such as a migration tool for data schema migrations and a framework for code markup.

Quality assurance

Quality assurance engineers in Wrike are responsible not only for manual testing, but for a wide range of adjacent activities: supporting and developing autotest framework, contributing to the autotest codebase, handling support tickets, and supervising the release process. That makes us sure that only the highest-quality product is delivered to our clients. 

Speedy feedback and fast delivery are crucial goals for our QA engineers. The shorter the cycle of feedback, the faster and easier the fix can be applied, which is why every QA is part of a Scrum team, getting involved in the development process from the very beginning and always keeping close contact with developers and product owners. 

Our work is in a fast-paced Agile environment with 30+ Scrum teams developing and supporting our product, with releases many times a day. To maintain quality in such a dynamic environment, we use dozens of thousands of automated tests written in modern frameworks and run them on a scalable cloud infrastructure. That allows our engineers to avoid performing tedious manual regression. 

And, since we believe in the full-stack QA approach without a strict separation of QA and QA automation, our quality assurance department develops internal test frameworks and tools written in Java, Kotlin, and Scala to help us maintain autotest code with ease. We contribute to open source software as well as use and create OSS solutions.

To help QAs without any development experience to become full-stack QA engineers, the QA team launched the Wrike QA automation school four years ago. During that time we fostered and mentored almost 50+ testers to learn how to code and start writing autotests. 

Wrike encourages self-development, so managers help employees in their professional growth. All our QA engineers have opportunities to find creative and innovative ways of working and introduce improvements everywhere, from tools to processes. We strongly believe in synergy between QA, QA automation, and development, so, with time and effort made, any Wrike QA engineer can grow into a QA full-stack engineer, QAA engineer, software developer (BE or FE), or QA expert/architect.

Stack: Java 17, JUnit 5, htmlelements 2.0 (wrapper for Selenium), Retrofit 2.0, Allure testops, and CI/CD tools

Work at Wrike

Data science/Machine learning (DS/ML)

As the leading collaborative work management platform, Wrike has a tremendous amount of data, which consists of content of work items, relations between entities, complex processes in accounts, user interactions with the system, etc. But the larger the account is, the harder it becomes to make use of the data in such raw format. The goal of the DS/ML department is to analyze and transform user data and create data-driven solutions that will give users valuable insights, improve productivity and user experience, and automate routine repetitive work.

Data-driven product features are required in many parts of the product, so the DS/ML department works in collaboration with teams responsible for different parts of the product by implementing the ML part of the solutions and providing expertise. 

Some examples of features where a data-driven approach is needed are:

  • Recommendations in all kinds of entity pickers (assignees, folders, mentions, etc.) to spend the minimum time on picking the right one
  • Personalised search to easily find the information and entities needed
  • Analysis of the state of projects to highlight risks and problematic aspects
  • Analysis of text content (title, description, comments) of work items to extract useful information like actionable subtasks, field updates, summaries

… and many more!

The work of the department is not limited to product development. Working closely with DevOps, we share MLOps responsibilities, ensuring our projects are efficient, scalable, and reliable, meeting the company’s needs. This includes flexible and convenient pipelines for automating data extraction, training, comparing, and serving models, as well as a set of tools to improve the productivity and reliability of our data science work.

Technology stack

Cloud: We use the Google Cloud Platform as our primary cloud solution — Vertex AI for ML, BigQuery for storing data, Cloud storage for models and other artefacts, etc.

Coding: We mostly code in Python. Black, Mypy, and Flake8 are our main libraries for code stability and style. We also actively use Pydantic to conveniently and reliably work with objects and configs.

DS/ML: We use a wide range of DS and ML tools depending on the goals and constraints of each project. Here are the most commonly used:

  • Pandas, NumPy, SciPy, and common visualization libs (like Matplotlib, Seaborn, Plotly) for data wrangling and analysis
  • Scikit-learn, LightGBM, and other common ML libraries for working with tabular data
  • TensorFlow and Keras for deep learning
  • SHAP for model interpretation
  • Optuna for hyperparameter tuning
  • MLflow for tracking experiments
  • Dagster for building pipelines
  • Langchain and OpenAI for generative AI prototyping


The DevOps team is the engine room of the company, accelerating the software delivery pipeline. We’re all about building and maintaining CI/CD, getting those updates and new features out the door and into the hands of users — quickly, securely, and frequently. 

We’re the bridge builders, breaking down the wall between development, QA, and operations, getting everyone on the same page by promoting communication and collaboration among the teams as one of our key principles.

Constant innovation: We’re always looking for ways to do things better, faster, and smarter. Seeking out processes and routines that can be automated. Our objective isn’t restricted to maintaining existing systems, it's about actively enhancing our company’s trajectory.

To keep pace with the constantly evolving industry and fulfill engineering needs, we establish, develop, and manage a highly scalable internal development platform dedicated to automating recurring or repetitive tasks. 

These include, but are not limited to:

  • Resource and environment provisioning with a set of component combinations and their versions. Devs spin up hundreds of dynamic stagings daily
  • Invoking around 500k FE and BE continuous integration jobs monthly
  • Initiating delivery of hundreds FE and BE apps to multiple production environments daily.

Our role as a platform team includes setting the standard for dynamic configuration management to evade disjointed scripting, which could culminate in extensive maintenance time.

It’s also significant to note that among other responsibilities, we uphold the dynamic on-demand Selenium infrastructure, thus facilitating the execution of over 60,000 browser tests on a daily basis in Kubernetes. Dealing with cloud infrastructure on such a scale requires us to closely monitor our cloud spending. In the process, we’ve acquired substantial experience in monitoring, optimizing, and improving cloud costs. 

Furthermore, we are delving into the realm of MLOps, which allows us to align with current industry demands effectively. In addition, as the product is multilingual, we also provide services for localization automatization.

We consider DORA metrics as a primary means of gauging our success. In accordance with these metrics, we and our product teams have accomplished elite performance status in the categories of deployment frequency and lead time for changes.

Infra stack:

  • GCP
  • Terraform, Ansible — infra provisioning
  • Kubernetes, GKE, Helm — container orchestration
  • GitLab CI, TeamCity — CI
  • Argo CD — CD 
  • VictoriaMetrics/Grafana/vmalert/PagerDuty — monitoring alerting
  • Fluent/Graylog — logs
  • PostgreSQL, Elasticsearch

Dev stack:

  • Microservices
  • Python 3.11
  • FastAPI
  • SQLAlchemy
  • Libs written in Rust such as MiniJinja
  • Pytest, Mypy, Black, Flake8, isort, unimport
  • Cloud SQL
  • TypeScript + Angular


Navigating the labyrinth of IT operations labels can be a daunting task. Are we a platform team? Do we fall under the DevOps, SRE, SysOps, or CloudOps umbrella? At the core of it all, we are creators, problem solvers, thinkers, and, above all, passionate tech enthusiasts.

Here at Wrike, our SysOps team is the custodian of the company’s infrastructure. We collaborate closely with the security, DevOps, and architecture teams to design, develop, and manage a robust and highly scalable infrastructure platform.

Our current primary objective is to strike the perfect balance between scalability, availability, and extensibility. We strive to adopt the best practices in the industry, aligning our operations with site reliability engineering (SRE) principles, while ensuring that our solutions are cost-effective — we certainly don’t want to be spending the equivalent of a Boeing wing on each one!

Technical stack:

  • Public clouds: GCP, AWS
  • Infrastructure provisioning: Terraform, Ansible
  • Container orchestration: Kubernetes, GKE, Helm
  • Continuous integration: GitLab CI, TeamCity
  • Proxying layer: Nginx/HAProxy/Istio
  • Continuous deployment: Argo CD
  • Monitoring and alerting: Zabbix/VictoriaMetrics/Grafana/Prometheus/PagerDuty
  • Logs: Fluent/Graylog
  • Product infrastructure stack: PostgreSQL, Elasticsearch, Kafka, Redis

Our SysOps team is the backbone of Wrike, ensuring the smooth running of our infrastructure while continually seeking ways to innovate and improve. We’re not just about maintaining systems — we’re about driving them forward.


The Mobile Unit consists of two cross-functional product teams that are organized around solving customer problems. The teams consist of iOS, Android, and backend engineers; manual and automation quality engineers; a product manager; a product designer; and an analyst. Our mission is to complement the Wrike web experience and maintain the set of features on mobile to make people more productive on the go. Our culture is very customer-focused — we care about delivering what customers really want while using Wrike on the web and/or mobile.

Our application is large and complex — one of the distinctive features of our mobile app is the support for offline mode, including the ability to edit data so you can use Wrike even while commuting. We invest in the quality of our internal solutions to minimize the cost of maintenance. In our teams, you can always find a task to your liking and promote your ideas to improve the product and its technical foundation.

Our Android stack includes Kotlin, Coroutines, and Flow; MVVM to build UI (not tying to Android ViewModel); and SQLCipher as a database with its own non-ORM wrapper over it, which is also written in Kotlin. Most of the application is covered by UI tests.

Our iOS stack includes Swift, Swift Package Manager, Combine, MVVM, and Realm as local data storage, as well as modular architecture of application screens. Most of the application is covered by UI tests. We’re implementing everything new in Swift, with only a few older features written in Objective-C.

QE stack: Espresso (Kotlin) + XCUITest (Swift) + Allure.

Agile delivery management

The Agile delivery management (ADM) team is responsible for orchestrating and optimizing the Agile development processes, ensuring efficiency, cross-functional collaboration, and customer centricity by delivering high-quality product increments in alignment with customer needs and business objectives. We work in an ever-changing environment, so our mission is to promote a culture of iterative development and remain flexible in our response to changes.

Within ADM, two synergistic teams come into play: unit/team managers and Agile Center of Excellence. These teams collaborate across three critical levels: team level, unit level, and the product engineering organization level.

Unit and team managers bear the responsibility of constructing and executing roadmaps, lineups, and synchronizing plans. Unit managers, positioned at the unit level, are responsible for the delivery of the entire unit, while team managers, operating at the team level, optimize work within their respective teams.

Agile Center of Excellence (Agile CoE) includes Scrum masters and Agile coaches. This team serves as an essential partner to product units across the organization. The Agile CoE plays not only a support function; it serves as the driving force behind Agile transformations, ensuring the effective adoption and implementation of Agile principles, values, and mindsets throughout the organization.

ADM strives to build a healthy dialogue between key stakeholders. It’s a conversation that involves product owners who articulate customer needs, functional managers who uphold technical excellence, team managers who plan and execute, and Scrum masters who are the catalysts of Agile thinking and development practices. This collaboration ensures that the Agile engine runs smoothly and that every product increment aligns with customer needs and business objectives.

Work at Wrike

Engineering values

At Wrike, our engineering values are built on the bedrock of our company-wide values. They guide all our departments towards our collective goals, shaping our engineering culture, and ensuring that through collaboration, execution, growth, and innovation, not only do we consistently deliver the best outcomes for our customers but also do the best work of our lives. They are not just words to us; they are the principles that drive our actions and decisions every day. Let’s have a look at what steers are in the right direction and what you can expect from Wrike’s engineering organization.

Deliver Business Outcomes

Completing tasks for the sake of completing tasks is not what we are after. We deliver impactful business outcomes that are driven by the ability to problem-solve and a proactive approach. We’re not focusing on minor details; we’re addressing real customer needs and enhancing their Wrike experience. We refuse to be set back by unnecessary perfectionism when we’ve already achieved a good enough result, saving valuable time for more significant challenges. We also value our employees’ foresight, encouraging them to consider potential future threats and opportunities, rather than sticking rigidly to the current task list. At Wrike, engineers are a vital part of our collective success story.

Be Better Than the Competition

We value employees’ awareness of the competitive landscape and curiosity about industry trends. Openness to new ideas and giving them a try fuels our innovation and is an essential component of our culture that allows us to stay on the cutting edge. But we understand that there’s no such thing as a perfect journey – mistakes are made and lessons are learned. Instead of making excuses, we make adjustments and grow from each experience. The curiosity, openness, and adaptability of our engineers make us a stronger team.

Move Fast. Then, Move Faster

To stay agile and be relevant in a fast-paced world, we set up a few rules to ensure that embracing change is as easy and comfortable as possible. We believe in the power of efficient and thoughtful work, where we aim to minimize waste and maximize value. Our team is committed to finding proactive solutions to new challenges rather than waiting for instructions. We discourage a mindset of simply doing what is told without concern for delivery, or resisting change and insisting on outdated methods of work. The mentality of deferring all decisions to managers without personal initiative is not our style. After all, we are about valuable outcomes over mere outputs.

Know Our Customers 

At Wrike, we put our customers at the heart of what we do. The outcomes-over-outputs approach plays a huge role here as well. We focus on solving real customer problems, rather than getting entangled in minor details that won’t resonate with our users. Our customer-centric approach goes beyond coding and allows us to create meaningful solutions that help millions of users around the world streamline their workflows, enhance collaboration, and accelerate execution across all departments. 

We Win Together

At Wrike, engineers are part of a team that embraces collaborative problem solving, sharing the load and the triumphs. We value the ability to work cohesively with others, prioritizing teamwork over solitary efforts. With shared goals and a collective context, one never has to feel like they’re facing challenges alone. So, say goodbye to the pressure of solitary responsibility and hello to the power of shared victory.

Have Courage

We are not afraid to raise concerns, drive changes, and make a difference. We encourage engineers to seek clarification on tasks they’re unsure about, regardless of their source, before diving in. On the other hand, we discourage a passive approach where one merely accepts everything from others without question or expects others to make decisions without proposing any solutions. We believe in constructive challenges and negotiations, not in disagreeing for the sake of disagreement. Courage is not just welcomed — it’s essential.

If you like what you see and want to join our team, we’d be happy to meet you! Apply to the open positions on our careers page.