Todo-Backend

a shared example to showcase backend tech stacks

The Todo-Backend project helps showcase and compare different language and framework combinations for building web services. This website defines a simple web API in the form of a todo list and users can create their own identical APIs using various tech stacks. This website then provides a spec runner to verify that the user implementation is identical to the base implementation.

The Todo-Backend project was inspired by the TodoMVC project, and some code (specifically the todo client app) was borrowed directly from TodoMVC.

featuring HTTP APIs built with:

aiohttp
Akka
Axon Framework
Azure Functions
Catalyst
Ceylon
Clojure
CoffeeScript
Compojure
CouchDB
Crystal
C#
Django
.NET
Dropwizard
Elixir
ES6
express.js
Finatra
Finch
Fintrospect
Flask
F#
Gin
Golang
Grape
gyokuro
Hapi.js
Haskell
http4k
Java
Javalin
JavaScript
JDBI
Jersey
Jodd
Jooby
JVM
Kemal
Kitura
Koa
Kotlin
Lagan
Laravel
lift
LittleBoxes
mangoo I/O
maru
Micro
Mojolicious
MongoDB
Nancy
NDatabase
Nim
node.js
nutzboot
OCaml
OWIN
Perl
Phoenix Framework
PHP
Play!
Postgres
Python
Rails
Ratpack
Redis
redux
restify
Rocket
Ruby
Rust
Scala
Scotty
Servant
ServiceStack
Sesame
Sinatra
Slim
Snap
Spark
Spincast
Spock
Spring
SWI-Prolog
Swift
Symfony2
Vert.x
VRaptor
web.py
Yesod

Implementations

filter by tag

aiohttp Akka Axon Framework Azure Functions Catalyst Ceylon Clojure CoffeeScript Compojure CouchDB Crystal C# Django .NET Dropwizard Elixir ES6 express.js Finatra Finch Fintrospect Flask F# Gin Golang Grape gyokuro Hapi.js Haskell http4k Java Javalin JavaScript JDBI Jersey Jodd Jooby JVM Kemal Kitura Koa Kotlin Lagan Laravel lift LittleBoxes mangoo I/O maru Micro Mojolicious MongoDB Nancy NDatabase Nim node.js nutzboot OCaml OWIN Perl Phoenix Framework PHP Play! Postgres Python Rails Ratpack Redis redux restify Rocket Ruby Rust Scala Scotty Servant ServiceStack Sesame Sinatra Slim Snap Spark Spincast Spock Spring SWI-Prolog Swift Symfony2 Vert.x VRaptor web.py Yesod

Perl / Catalyst

todo backend implemented with perl and Catalyst. Backed with a plain file on disk.

Perl / Mojolicious

todo backend implemented with perl and mojolicious. Backed with a plain file on disk.

Perl / PEF::Front

todo backend implemented with perl and PEF::Front. web framework, saving todos to a Postgres DB.

Ruby / Sinatra

A simple ruby implementation using the lightweight Sinatra web framework, saving todos to a Postgres DB.

Ruby / Grape

A Ruby implementation using Grape.

Rust / Iron

A Rust implementation using Iron with a thread-safe in-memory repository

Rust / Rocket

A Rust implementation using Rocket.

Node.js / Express

Node.js + Express, saving to Postgres. Courtesy of Daniel Tao.

Node.js / Express / JS-CSP

Node.js + Express + JS-CSP (an alternative to Promises and callbacks), saving to Postgres. Courtesy of Andrew Kiellor.

Node.js / Hapi.js

Hapi.js saving to a MongoDB collection via MongooseJS by Pamela Ocampo.

Node.js / Hapi.js / Postgres

Node.js example using the Hapi framework and a Bookshelf ORM connected to a Postgres database.

Node.js / Micro / Postgres

Node.js example using the Micro framework.

Python / web.py

A simple Python implementation using web.py. This implementation "cheats" by just storing todos in memory in a Dictionary globalton.

Clojure / Compojure

A simple Compojure implementation storing to Postgres via clojure.java.jdbc courtesy of Andrew Kiellor.

Clojure / Compojure / H2 Database

A simple Compojure implementation storing to H2 File DB via clojure.java.jdbc courtesy of Darren Haken.

Python / Django

A database-backed Django implementation courtesy of Mihir Khatwani.

Vanilla Rails

A simple Rails implementation courtesy of Derek Hammer.

Java with ActFramework and MongoDB

A version using ActFramework by Gelin Luo.

Java 8 with Spring 4 Boot

A version using Spring 4 Boot + Java 8 from Jefferson Santos.

Java 7 and Spring MVC

Java 7 and Spring MVC implementation using the Java 1.7 and Spring MVC. Deployed to Heroku using a Tomcat runner.

Vert.x and PostgreSQL

Backend, based on Vert.x 3 and PostgreSQL.

Java 8 and Vert.x

An implementation using Java 8 and Vert.x from Alex Somai.

Vert.x with JDBC

An implementation using Vert.x with JDBC from Dong-hee Na.

Vert.x with ORM

An implementation using Vert.x with ORM(ormlite) from Dong-hee Na.

Jersey2 with RDF for data storage

A version using Jersey2 with Sesame RDF for data storage from Michael Leuthold.

Golang / Gin

A Golang implementation using the Gin web framework, courtesy of Matt Ho.

Golang / GOA

A Golang implementation using the GOA web framework, courtesy of Christoph Meier.

Scala / Lift

A Scala implementation using the Lift framework. This implementation uses a thread-safe in-memory store. Courtesy of Riccardo Sirigu.

Scala / Finatra

A Scala implementation using Twitter's Finatra web framework. Courtesy of the prolific Matt Ho.

Scala / Akka

A Scala implementation using akka-http. Courtesy of Arnout Engelen

Kotlin / Http4k

Kotlin + http4k with typesafe lenses, saving in-memory.

Kotlin / Rapidoid

Kotlin + Rapidoid, saving im-memory.

Node.js / Koa

Node.js + Koa, saving to redis.

SWI-Prolog

SWI-Prolog 7 implementation using the Prolog database with persistency. Extensively documented.

C# - Nancy (ASP.NET)

C# with NancyFx implementation using the Nancy Framework and NDatabase, an inmemory object database.

F# - Freya (OWIN)

F# with Freya implementation using the Freya F# OWIN wrapper and an in-memory store built with an F# `MailboxProcessor`.

Java Spring 4.0 and MongoLab DbaaS

Java Spring MongoLab DbaaS implementation using the Java 1.7, Spring 4.0 and MongoDB using MongoLab's database as a service.

Vert.x 3 and Redis backend

A Java implementation using Vert.x with Redis backend. Deployed on OpenShift. By Eric Zhao

F# - ASP.NET Web API

F# with ASP.NET Web API implementation using ASP.NET Web API 2.2, F#, hosted via OWIN, and using an in-memory store built with an F# `MailboxProcessor`.

F# - Frank

F# with Frank implementation using Frank, a minimal combinator library built on top of System.Net.Http types in F#, hosted via OWIN, and using an in-memory store built with an F# `MailboxProcessor`.

Java with Dropwizard

Simple implementation with Java + Dropwizard from Dan Siwiec.

C# with ServiceStack

An implementation using the ServiceStack framework, ormlite, sqlite, NUnit by Kyle Hodgson.

C# - ASP.NET Web API

C# with ASP.NET Web API implementation using ASP.NET Web API 2.2, C#, and a simple in-memory list for storage.

Golang / stdlib

A Golang implementation using only the standard libraries

Vert.x / Mongo / Java8

Implemented using Vert.x + MongoDB, written in Java8 from Vithulan

Node.js / Express / CoffeeScript / Mongo

Node.js + Express, written in CoffeeScript from Dan Siwiec. Data is persisted to MongoDB using Mongoose

F# - Suave

A simple implementation using Suave

Scala - Play!

Scala implementation on the Play framework backed by Postgres

OCaml

OCaml implementation. Courtesy of Arnout Engelen

Elixir - Phoenix / Postgres

Elixir implementation using the Phoenix Framework backed by Postgres. Deployed to Heroku using the Elixir buildpack. Courtesy of Jeff Weiss

Elixir - Maru / Postgres

Elixir implementation using the Maru Framework and Ecto ORM backed by Postgres. Deployed to Heroku using the Elixir buildpack. By Charles Whitfield

Elixir - Plug / Postgres

Elixir implementation using the Elixir Plug and Ecto ORM backed by Postgres. Deployed to Heroku using the Elixir buildpack. By Rajesh Sharma

Java - Axon + Spring Boot

Implementation using Axon, a Java CQRS framework, + Spring Boot. This version "cheats" by storing todos in an in-memory repository. By Ryan Oglesby

Python / Flask

Implementation written in Python with Flask.

Python / Circuits

Implementation written in Python with Circuits Framework.

Python / aiohttp

Implementation written in Python 3.5 with aiohttp by Justus Perlwitz.

Python / Falcon

Implementation written in Python 2.7 with Falcon.

Haskell - Scotty / Persistent

Haskell implementation using Scotty.

Haskell - Servant / Persistent

Haskell implementation using Servant.

Haskell - Snap / Persistent

Haskell implementation using Snap.

Haskell - Spock / Persistent

Haskell implementation using Spock.

Haskell - Yesod / Persistent

Haskell implementation using Yesod.

Rust / Rustful

Rust implementation using Rustful.

PHP / Symfony2

PHP implementation with Symfony2.

Modern Node.js / MongoDB

Node.js implementation using ES6/7 features, built with libraries from Matt Insler. Features use of app-context.

Node.js / Restify / Redux

Node.js + Restify, written with pure ES6 from Dan Siwiec. State is maintained with Redux

TypeScript / Node.js / Express

TypeScript + Node.js + Express, saving to Postgres.

Slim 3 / Spot

PHP implementation with Slim 3 and Spot.

Scala / Finch

A Scala implementation using Finch for web and Circe for JSON.

Scala / Fintrospect

A Scala implementation using Fintrospect for web and Json4s for JSON.

Swift / Kitura / CouchDB

A Swift implementation using Kitura for web.

Swift / Vapor

A Swift implementation using Vapor for web.

Scala - Play 2.5 / Postgres

A Scala implementation using Play 2.5 with persistance in Postgres using Anorm. By Jorge Lee.

Spincast Framework ~ In memory

In memory implementation using Spincast.

Scala - Spring Boot

A Scala implementation using Spring Boot By Steven Job.

Nim / Jester

Nim + Jester using in-memory data store. By Cody Ebberson.

Crystal / Kemal ~ In memory

A Crystal implementation using Kemal.

Scala / http4s (in-memory)

A Scala and http4s implementation with an in-memory store

Rails 5 API-only

A Rails 5 API-only implementation with MongoDB Backend.

Java 8 / Ratpack

A Java 8 implementation using the Ratpack framework, using H2 for persistance

Jooby / In memory

Jooby implementation using with an in-memory store

Java 8 / Spark / JDBI

A Java 8 implementation using the Spark framework. Persistance to Postgres using JDBI.

C# - ASP.NET Core

A C# implementation using ASP.NET Core with Docker support and in-memory or SqlServer persistence. Implements CQS using the Brighter and Darker frameworks.

PHP / Lagan

PHP implementation with Lagan.

Azure Functions - C#, F# and JavaScript

Azure Functions implementation with functions written in C#, F# and JavaScript. Uses Azure Table Storage for persistence.

Java / VRaptor 4 / JPA / H2 Database

A Java implementation using VRaptor 4 framework.

Vanilla Ceylon

Plain Ceylon implementation by Andreas Schilling.

Ruby / LittleBoxes

A Ruby implementation using LittleBoxes.

mangoo I/O / jOOQ / H2

A Java 8 implementation using the Mangoo I/O framework, jOOQ for database access and H2 in-memory database.

Ceylon / gyokuro

A Ceylon implementation using the gyokuro framework.

Kotlin / Spring Boot 2 reactive with annotation

Simple implementation using Spring Boot 2 (reactive web) and with Kotlin, saving todos in-memory.

Kotlin / Spring Boot 2 reactive with router

Simple implementation using Spring Boot 2 (reactive web) and with Kotlin, saving todos in-memory. Setup is done via the router API

Kotlin / Spring Boot 2 reactive with mongodb

Implementation using Spring Boot 2 (reactive web) and Kotlin. Data source is mongo

Kotlin / Spring Boot

Implementation using Kotlin and Spring Boot. Items are stored in memory.

Kotlin / Javalin

Implementation using Kotlin and Javalin. Items are stored in memory.

C# - ASP.NET Core 2.0

A simple C# implementation using ASP.NET Core 2.0 with a Docker image and in-memory persistence. Only depends on the standard Microsoft.AspNetCore.All package.

PHP / Laravel

PHP implementation using Laravel and a MySQL database

Java / Jodd

Java 8 implementation using Jodd 4.

XCST - ASP.NET

An XCST implementation for ASP.NET. Items are stored in memory.

Java with NutzBoot

Implementation using Nutz Boot by wendal. Items are stored in memory.

{YOUR IMPLEMENTATION HERE}


It's very simple to build your own Todo-Backend implementation. It shouldn't take more than a few hours. Read more.