diff --git a/modules/spring-tx-ext/examples/main/java/org/apache/ignite/transactions/spring/examples/IgniteClientTransactionalService.java b/modules/spring-tx-ext/examples/main/java/org/apache/ignite/transactions/spring/examples/IgniteClientTransactionalService.java
new file mode 100644
index 0000000..1d37301
--- /dev/null
+++ b/modules/spring-tx-ext/examples/main/java/org/apache/ignite/transactions/spring/examples/IgniteClientTransactionalService.java
@@ -0,0 +1,135 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.transactions.spring.examples;
+
+import java.io.Serializable;
+import java.util.Objects;
+import org.apache.ignite.client.ClientCache;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import static org.springframework.transaction.annotation.Isolation.READ_COMMITTED;
+import static org.springframework.transaction.annotation.Isolation.REPEATABLE_READ;
+
+/**
+ * Represents Spring Service that uses Ignite thin client to access Ignite cluster and perform cache transactional
+ * operations.
+ */
+@Service
+public class IgniteClientTransactionalService {
+    /** Ignite cache representation that uses thin client to communicate with Ignite cluster. */
+    private ClientCache<String, Account> cache;
+
+    /**
+     * The emitters transfer the specified funds to the broker. When both funds are received, they are transferred to
+     * the recipient, excluding the fee which the broker keeps for himself. If an error occurs at any step of this
+     * operation, it is rolled back.
+     */
+    @Transactional(isolation = REPEATABLE_READ)
+    public void transferFundsWithBroker(
+        String firstEmitter,
+        String secondEmitter,
+        String recipient,
+        String broker,
+        int funds,
+        int fee
+    ) {
+        transferFunds(firstEmitter, broker, funds);
+
+        transferFunds(secondEmitter, broker, funds);
+
+        transferFunds(broker, recipient, funds * 2 - fee);
+    }
+
+    /** Transfers funds between two accounts that belong to users with the specified names. */
+    @Transactional(isolation = REPEATABLE_READ)
+    public void transferFunds(String emitter, String recipient, int funds) {
+        Account emitterAcc = cache.get(emitter);
+        Account recipientAcc = cache.get(recipient);
+
+        if (emitterAcc.balance < funds)
+            throw new RuntimeException("Insufficient funds in " + emitter + "'s account");
+
+        emitterAcc.balance -= funds;
+        recipientAcc.balance += funds;
+
+        saveAccount(emitterAcc);
+        saveAccount(recipientAcc);
+
+        System.out.println(">>> " + emitter + " transfers " + funds + " coins to " + recipient);
+    }
+
+    /** Gets current balance of the account with the specified name.*/
+    @Transactional(isolation = READ_COMMITTED)
+    public int getBalance(String login) {
+        return cache.get(login).balance;
+    }
+
+    /** Creates account with the specified user login and balance. */
+    public Account createAccount(String login, int balance) {
+        Account acc = new Account(login);
+
+        acc.balance = balance;
+
+        cache.put(login, acc);
+
+        return acc;
+    }
+
+    /** Sets an Ignite cache representation that uses thin client to communicate with the Ignite cluster. */
+    public void setCache(ClientCache<String, Account> cache) {
+        this.cache = cache;
+    }
+
+    /** Puts the specified account into the cache. */
+    private void saveAccount(Account acc) {
+        cache.put(acc.login, acc);
+    }
+
+    /** Represents the user account. */
+    private static class Account implements Serializable {
+        /** Account owner login. */
+        private final String login;
+
+        /** Balance. */
+        private int balance;
+
+        /** Creates an account with the specified owner name. */
+        public Account(String login) {
+            this.login = login;
+        }
+
+        /** {@inheritDoc} */
+        @Override public boolean equals(Object other) {
+            if (this == other)
+                return true;
+
+            if (other == null || getClass() != other.getClass())
+                return false;
+
+            Account acc = (Account)other;
+
+            return balance == acc.balance && Objects.equals(login, acc.login);
+        }
+
+        /** {@inheritDoc} */
+        @Override public int hashCode() {
+            return Objects.hash(login, balance);
+        }
+    }
+}
diff --git a/modules/spring-tx-ext/examples/main/java/org/apache/ignite/transactions/spring/examples/SpringTransactionExample.java b/modules/spring-tx-ext/examples/main/java/org/apache/ignite/transactions/spring/examples/SpringTransactionExample.java
new file mode 100644
index 0000000..e534334
--- /dev/null
+++ b/modules/spring-tx-ext/examples/main/java/org/apache/ignite/transactions/spring/examples/SpringTransactionExample.java
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.transactions.spring.examples;
+
+import org.apache.ignite.Ignite;
+import org.apache.ignite.Ignition;
+import org.apache.ignite.client.ClientCacheConfiguration;
+import org.apache.ignite.client.IgniteClient;
+import org.apache.ignite.configuration.ClientConfiguration;
+import org.apache.ignite.transactions.spring.IgniteClientSpringTransactionManager;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import static org.apache.ignite.cache.CacheAtomicityMode.TRANSACTIONAL;
+import static org.apache.ignite.configuration.ClientConnectorConfiguration.DFLT_PORT;
+import static org.apache.ignite.transactions.TransactionConcurrency.PESSIMISTIC;
+
+/** Represents example of using Ignite Spring Transactions integration with the thin client. */
+public class SpringTransactionExample {
+    /** Ignite cache name. */
+    public static final String ACCOUNT_CACHE_NAME = "example-account-cache";
+
+    /** */
+    public static void main(String[] args) {
+        try (
+            Ignite ignored = Ignition.start(); // Starts an Ignite cluster consisting of one server node.
+            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext()
+        ) {
+            ctx.register(SpringApplicationConfiguration.class);
+            ctx.refresh();
+
+            IgniteClientTransactionalService svc = ctx.getBean(IgniteClientTransactionalService.class);
+
+            svc.createAccount("Bob", 1000);
+            svc.createAccount("Alice", 100);
+            svc.createAccount("Eve", 0);
+            svc.createAccount("Dave", 0);
+
+            doFundTransferWithBroker(svc, "Bob", "Alice", "Eve", "Dave", 1000, 10);
+
+            doFundTransferWithBroker(svc, "Bob", "Alice", "Eve", "Dave", 100, 10);
+        }
+    }
+
+    /** Delegates funds transfer operation to {@link IgniteClientTransactionalService} and logs the result. */
+    private static void doFundTransferWithBroker(
+        IgniteClientTransactionalService svc,
+        String firstEmitter,
+        String secondEmitter,
+        String recipient,
+        String broker,
+        int cash,
+        int fee
+    ) {
+        System.out.println("+--------------Fund transfer operation--------------+");
+
+        try {
+            svc.transferFundsWithBroker(firstEmitter, secondEmitter, recipient, broker, cash, fee);
+
+            System.out.println(">>> Operation completed successfully");
+        }
+        catch (RuntimeException e) {
+            System.out.println(">>> Operation was rolled back [error = " + e.getMessage() + ']');
+        }
+
+        System.out.println("\n>>> Account statuses:");
+
+        System.out.println(">>> " + firstEmitter + " balance: " + svc.getBalance(firstEmitter));
+        System.out.println(">>> " + secondEmitter + " balance: " + svc.getBalance(secondEmitter));
+        System.out.println(">>> " + recipient + " balance: " + svc.getBalance(recipient));
+        System.out.println(">>> " + broker + " balance: " + svc.getBalance(broker));
+        System.out.println("+---------------------------------------------------+");
+    }
+
+    /** Spring application configuration. */
+    @Configuration
+    @EnableTransactionManagement
+    public static class SpringApplicationConfiguration {
+        /**
+         * Ignite thin client instance that will be used to both initialize
+         * {@link IgniteClientSpringTransactionManager} and perform transactional cache operations.
+         */
+        @Bean
+        public IgniteClient igniteClient() {
+            return Ignition.startClient(new ClientConfiguration().setAddresses("127.0.0.1:" + DFLT_PORT));
+        }
+
+        /** Ignite implementation of the Spring Transactions manager interface. */
+        @Bean
+        public IgniteClientSpringTransactionManager transactionManager(IgniteClient cli) {
+            IgniteClientSpringTransactionManager mgr = new IgniteClientSpringTransactionManager();
+
+            mgr.setClientInstance(cli);
+            mgr.setTransactionConcurrency(PESSIMISTIC);
+
+            return mgr;
+        }
+
+        /** Service instance that uses declarative transaction management when working with the Ignite cache. */
+        @Bean
+        public IgniteClientTransactionalService transactionalService(IgniteClient cli) {
+            IgniteClientTransactionalService svc = new IgniteClientTransactionalService();
+
+            svc.setCache(cli.getOrCreateCache(new ClientCacheConfiguration()
+                .setName(ACCOUNT_CACHE_NAME)
+                .setAtomicityMode(TRANSACTIONAL)));
+
+            return svc;
+        }
+    }
+}
diff --git a/modules/spring-tx-ext/pom.xml b/modules/spring-tx-ext/pom.xml
index 4fd5c1d..b43da49 100644
--- a/modules/spring-tx-ext/pom.xml
+++ b/modules/spring-tx-ext/pom.xml
@@ -95,4 +95,52 @@
             </testResource>
         </testResources>
     </build>
+
+    <profiles>
+        <profile>
+            <id>examples</id>
+
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>build-helper-maven-plugin</artifactId>
+                        <executions>
+                            <execution>
+                                <phase>generate-sources</phase>
+                                <goals>
+                                    <goal>add-source</goal>
+                                </goals>
+                                <configuration>
+                                    <sources>
+                                        <source>examples/main/java</source>
+                                    </sources>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+
+            <dependencies>
+                <dependency>
+                    <groupId>org.apache.ignite</groupId>
+                    <artifactId>ignite-spring</artifactId>
+                    <version>${ignite.version}</version>
+                </dependency>
+
+                <dependency>
+                    <groupId>org.apache.ignite</groupId>
+                    <artifactId>ignite-core</artifactId>
+                    <version>${ignite.version}</version>
+                </dependency>
+
+                <dependency>
+                    <groupId>org.springframework</groupId>
+                    <artifactId>spring-tx</artifactId>
+                    <version>${spring.version}</version>
+                </dependency>
+            </dependencies>
+        </profile>
+    </profiles>
 </project>