diff --git a/site/_posts/2018-11-19-r-spark-improvements.md b/site/_posts/2018-11-19-r-spark-improvements.md
new file mode 100644
index 00000000000..b2b148d28b1
--- /dev/null
+++ b/site/_posts/2018-11-19-r-spark-improvements.md
@@ -0,0 +1,198 @@
+---
+layout: post
+title: "Speeding up R with Spark using Apache Arrow"
+date: "2019-01-20 08:00:00 -0800"
+author: javierluraschi
+categories: [application]
+---
+
+
+*[Javier Luraschi][1] is a software engineer at [RStudio][2]*
+
+Support for Apache Arrow in Apache Spark with R is currently under active
+development in the [sparklyr][3] and [SparkR][4] projects. This post explores early, yet
+promising, performance improvements achieved when using R with [Apache Spark][5],
+Arrow and `sparklyr`.
+
+# Setup
+
+Since this work is under active development, install `sparklyr` and
+`arrow` from GitHub as follows:
+
+```r
+devtools::install_github("apache/arrow", subdir = "r", ref = "apache-arrow-0.12.0")
+devtools::install_github("rstudio/sparklyr", ref = "apache-arrow-0.12.0")
+```
+
+In this benchmark, we will use [dplyr][6], but similar improvements can
+be expected from using [DBI][7], or [Spark DataFrames][8] in `sparklyr`.
+The local Spark connection and dataframe with 10M numeric rows was
+initialized as follows:
+
+```r
+library(sparklyr)
+library(dplyr)
+
+sc <- spark_connect(master = "local", config = list("sparklyr.shell.driver-memory" = "6g"))
+data <- data.frame(y = runif(10^7, 0, 1))
+```
+
+# Copying
+
+Currently, copying data to Spark using `sparklyr` is performed by persisting
+data on-disk from R and reading it back from Spark. This was meant to be used
+for small datasets since there are better tools to transfer data into
+distributed storage systems. Nevertheless, many users have requested support to
+transfer more data at fast speeds into Spark.
+
+Using `arrow` with `sparklyr`, we can transfer data directly from R to
+Spark without having to serialize this data in R or persist in disk.
+
+The following example copies 10M rows from R into Spark using `sparklyr`
+with and without `arrow`, there is close to a 16x improvement using `arrow`.
+
+This benchmark uses the [microbenchmark][9] R package, which runs code
+multiple times, provides stats on total execution time and plots each
+excecution time to understand the distribution over each iteration.
+
+```r
+microbenchmark::microbenchmark(
+ setup = library(arrow),
+ arrow_on = {
+ sparklyr_df <<- copy_to(sc, data, overwrite = T)
+ count(sparklyr_df) %>% collect()
+ },
+ arrow_off = {
+ if ("arrow" %in% .packages()) detach("package:arrow")
+ sparklyr_df <<- copy_to(sc, data, overwrite = T)
+ count(sparklyr_df) %>% collect()
+ },
+ times = 10
+) %T>% print() %>% ggplot2::autoplot()
+```
+```
+ Unit: seconds
+ expr min lq mean median uq max neval
+ arrow_on 3.011515 4.250025 7.257739 7.273011 8.974331 14.23325 10
+ arrow_off 50.051947 68.523081 119.946947 71.898908 138.743419 390.44028 10
+```
+
+
+
+
+
+
+
+