FLOWABLE QUESTIONS

Beginner (10 Questions)

1. What is Flowable, and why is it used in business process management (BPM)?

2. Explain the basic components of BPMN (Business Process Model and Notation) as used in
Flowable.

3. How does Flowable differ from other BPM tools like Camunda or Activiti?

4. What is a process instance in Flowable, and how do you start one?

5. Can you describe what a task is in Flowable and the different types of tasks you can create?

6. How do you deploy a process definition in Flowable?

7. What is the purpose of the Flowable Modeler, and how is it typically used?

8. Describe how Flowable handles form data.

9. What is a gateway in BPMN, and what types of gateways are supported in Flowable?

10. How do you access Flowable’s REST API, and what are some of its common endpoints?

Medium (10 Questions)

11. Explain how to configure a simple process in Flowable with user tasks, service tasks, and
gateways.

12. What is a boundary event in Flowable, and when would you use one?

13. How would you handle exceptions in a Flowable process?

14. Describe how Flowable integrates with Spring Boot and how you set up the dependencies.

15. How do you customize task listeners in Flowable, and what are some practical uses of task
listeners?

16. Can you explain how Flowable handles variables within a process?

17. How would you implement conditional flows in a Flowable process?

18. What is a timer event in Flowable, and how do you set it up?

19. Explain how Flowable allows for custom scripting and the use of Java or JavaScript
expressions.

20. Describe a scenario where you’d use a message event in Flowable.

Advanced (30 Questions)

21. Explain how Flowable handles persistence and the underlying database structure. How
have you managed data persistence issues in Flowable projects?
22. How do you monitor and optimize the performance of Flowable processes in a production
environment?

23. What’s your experience with Flowable's Event Registry, and how do you use it in event-
driven architectures?

24. How do you implement a custom service task in Flowable, and what are the steps for
integration?

25. Explain how you would create and manage a complex BPMN model with multiple
subprocesses in Flowable.

26. How do you configure and utilize Flowable’s TaskService for task management?

27. In your experience, what are the best practices for versioning and updating Flowable
process definitions in production?

28. What strategies do you use to ensure data integrity when working with Flowable's form
data and custom tables?

29. How have you dealt with performance bottlenecks when running Flowable in a
microservices architecture?

30. What experience do you have with Flowable’s async capabilities, and when do you use
asynchronous tasks?

31. How do you handle external system integrations (like RESTful services) within a Flowable
process?

32. Describe how Flowable’s IdentityService is used for managing users and groups.

33. What steps do you follow to trigger a receive task in Flowable, and how would this be
different from handling a send event task?

34. How do you implement authorization and access control in a Flowable-based application?

35. Explain your approach to testing BPMN workflows in Flowable. What tools and strategies
do you use?

36. What troubleshooting steps do you take when encountering errors in Flowable’s REST API?

37. Describe a complex Flowable workflow you’ve designed and the challenges you faced in its
implementation.

38. How do you handle process instance migration in Flowable if a process definition changes?

39. Explain the function of a compensation event in Flowable and when you might use it.

40. How do you manage long-running processes and asynchronous tasks in Flowable to ensure
reliability?

41. Describe your experience in customizing the Flowable UI to meet specific project
requirements.

42. What’s your approach to logging and monitoring events in a Flowable application?

43. How do you create and execute custom queries in Flowable using SQL or JPQL?
 44. What is the Flowable Job Executor, and how do you manage job retries and failures?

45. Describe your experience with Flowable’s ProcessEngineConfiguration and its

customization options.

46. How would you structure a Flowable project that requires integration with Kafka or
RabbitMQ for messaging?

47. Explain the role of Flowable’s HistoryService and how you retrieve process instance history.

48. How do you optimize Flowable for high-availability and distributed deployments?

49. Describe a troubleshooting process for resolving NullPointerExceptions related to Flowable

services.

50. What’s your approach to handling Flowable upgrades and maintaining compatibility with
custom code?

Beginner-Level Coding Questions

1. Write a simple BPMN process definition in XML with two user tasks and an exclusive
gateway.

2. Create a Spring Boot configuration to set up Flowable dependencies and connect to an H2

database.

3. Write a Java code snippet to start a process instance in Flowable using the RuntimeService.

4. Implement a simple user task completion using Flowable’s TaskService.

5. Use Flowable’s REST API to deploy a process definition. Write the HTTP request details.

Medium-Level Coding Questions

1. Implement a service task in Flowable to call an external REST API using Java.

2. Write a Flowable task listener to capture and log details whenever a task is created or
completed.

3. Demonstrate how to create and use process variables in a Flowable process, showing code
for both setting and retrieving them.

4. Write code to query all active tasks for a specific user using Flowable’s TaskService.

5. Create a timer boundary event in BPMN and configure it in a process to trigger after a set
interval.

Advanced-Level Coding Questions

1. Write code to retrieve historical data for a process instance using Flowable’s
HistoryService.
 2. Implement a custom ExecutionListener for process start and end events and demonstrate
how to attach it to a process.

3. Write Java code to trigger a receive task using Flowable’s RuntimeService (e.g., triggering a
message receive event).

4. Demonstrate how to handle conditional flows in BPMN with code examples using
expression language.

5. Create a custom query using Flowable’s native queries to retrieve all tasks for a specific
business key.

6. Show how to inject and configure a JdbcTemplate in a Flowable TaskListener for custom
database operations.

7. Write code to implement an asynchronous service task and configure the job retry
mechanism.

8. Implement a send event task in a Flowable process to send a message to another process
and provide code for setting it up.

9. Write a Flowable script task using JavaScript to perform a simple calculation and store the
result in a process variable.

10. Demonstrate how to implement a process instance migration for instances affected by a
process definition update.

REST API Questions

1. Explain the REST architectural style and its key principles (like statelessness, resource
representation).

2. What HTTP methods are commonly used in REST, and what are their purposes?

3. How do you design a REST API to manage resources with CRUD operations? Provide an
example.

4. Write a RESTful endpoint to retrieve a specific record by ID, using Spring Boot.

5. How do you handle errors in REST APIs, and how would you return meaningful error
messages?

6. What is RESTful API versioning, and why is it important?

7. Describe how you would secure a REST API. What options are available in Spring Boot for
securing endpoints?

8. Explain the role of @RestController and @RequestMapping annotations in Spring Boot.

 9. Write a code snippet to create a REST endpoint that accepts a JSON payload and saves it to
a database.

10. How do you test REST APIs? What tools or methods have you used (e.g., Postman, JUnit)?

Java Questions

1. What is dependency injection, and how does it work in Spring?

2. Explain the difference between @Autowired, @Qualifier, and @Primary in Spring.

3. How would you handle exceptions in a Java application, and what best practices do you
follow for exception handling?

4. Write a Java method to fetch data from a REST API and process the response.

5. What are Java streams, and how would you use them to filter and process data?

6. How do you manage transactions in Java with Spring, and what is the purpose of
@Transactional?

7. Explain the concepts of microservices and how they can be implemented with Spring Boot.

8. Write a simple Java code example to connect to a database and execute a SQL query.

9. What are some common design patterns you use in Java, and how do they help structure
code?

10. How do you optimize Java applications for better performance?

Database Questions

1. What is normalization in databases, and why is it important?

2. Explain the differences between SQL and NoSQL databases.

3. How do you handle database migrations in a Java project, and what tools do you use (e.g.,
Flyway, Liquibase)?

4. Write a SQL query to find all records in a table where a particular column matches a value.

5. How do you optimize SQL queries for better performance?

REST with Flowable

1. Explain how you can start a Flowable process instance using Flowable’s REST API. Provide
the necessary endpoint and parameters.

2. How do you query active tasks in Flowable for a particular user via REST API? Describe the
endpoint and JSON structure required.

3. Write a REST API endpoint in Java (Spring Boot) to complete a user task in Flowable,
including code for passing task variables.
 4. Describe how you would design a custom REST API in Java to retrieve historical process
instance data from Flowable.

5. Explain how Flowable’s REST API handles pagination and filtering for process instances,
and provide an example.

6. How would you handle authentication and authorization for Flowable’s REST API to ensure
secure process management?

7. Create a Spring Boot REST controller that starts a Flowable process, takes user input, and
passes it as process variables.

8. How can you trigger a message event in Flowable using a custom REST endpoint in Java?
Describe the endpoint and payload structure.

9. Explain how you’d use Flowable’s REST API to deploy a new BPMN process definition and
list all deployed definitions.

10. Discuss the use of HTTP status codes in Flowable’s REST API. What response codes would
you expect for various API operations (e.g., task completion, process start)?

Java with Flowable

1. Write Java code to interact with Flowable’s RuntimeService to start a new process
instance.

2. How would you implement a service task in a Flowable BPMN model that calls an external
REST API using Java? Show the code.

3. Explain the role of TaskService in Flowable and demonstrate how to claim and complete a
task programmatically in Java.

4. How do you handle exceptions in Flowable processes? Write code to demonstrate

exception handling in a Java delegate.

5. Show how to create a custom task listener in Java to log task assignment and completion
events in Flowable.

6. What are Flowable expressions, and how would you use Java expressions in BPMN
workflows? Provide an example.

7. How would you implement and configure a Java ExecutionListener to execute custom logic
on the start and end of a process instance?

8. Explain the function of the HistoryService in Flowable and write a Java code snippet to
query completed process instances.

9. Write a Java program to trigger a Flowable receive task programmatically and provide an
example of when you might use it.

10. Describe how to configure and use Java’s async tasks in Flowable. Why would you choose
to use asynchronous processing?

Database with Flowable

1. Explain how Flowable persists process data in a relational database and describe the key
tables involved (e.g., ACT_RU_TASK, ACT_HI_PROCINST).

2. How would you design a database query to retrieve all active tasks for a particular process
instance using Flowable’s tables?

3. Explain how Flowable handles history and audit data. How would you retrieve historical
data for a process instance?

4. How do you configure Flowable to connect to a custom database in a Spring Boot

application? Show configuration steps.

5. Describe a situation where you would need to create a custom database query in Flowable.
Provide an example.

6. How can you use Flowable’s JdbcTemplate for custom SQL queries, and what are best
practices when accessing data in Flowable tables?

7. How do you map process variables to database fields in Flowable for reporting or custom
storage requirements?

8. Explain how you would manage database migrations when deploying Flowable BPMN
changes in a production environment.

9. What are the differences between runtime and historical tables in Flowable, and when
should you query each?

10. Describe how Flowable handles transactional integrity and database rollbacks for failed
tasks. Provide an example.