Todo-Backend

a shared example to showcase backend tech stacks

The Todo-Backend project defines a simple web API spec - for managing a todo list. Contributors implement that spec using various tech stacks. Those implementations are cataloged below. A spec runner verifies that each contribution implements the exact same API, by running an automated test suite which defines the API.

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

Created and curated by Pete Hodgson.

featuring HTTP APIs built with:

aiohttp
Akka
API Platform
Axon Framework
Azure Functions
Azure SQL
CakePHP
Catalyst
Ceylon
Clear
Clojure
CoffeeScript
Compojure
Couchbase
CouchDB
Crystal
C#
Django
.NET
Dropwizard
Elixir
ES6
express.js
Finatra
Finch
Fintrospect
Flask
Flyway
F#
Gin
Go kit
Golang
GORM
GraalVM
Gradle
Grape
gyokuro
Hanami
Hapi.js
Haskell
Hexagon
http4k
immutant
Java
Java EE
Javalin
JavaScript
JDBI
Jersey
Jodd
Jooby
JVM
Kemal
Kitura
Knex.js
Koa
Koin
Kotlin
Ktor
Lagan
Laravel
lift
LittleBoxes
luminus
mangoo I/O
maru
Masonite
Micro
Micronaut
Mojolicious
MongoDB
Nancy
NDatabase
NeDB
Nim
node.js
nutzboot
OCaml
OWIN
Perl
Pharo
Phoenix Framework
PHP
Play!
plumber
Postgres
Python
Quarkus
Rails
Ratpack
Redis
redux
Reitit
restify
Rocket
R
Ruby
Rust
Scala
Scotty
Seaside
Servant
ServiceStack
Sesame
Sinatra
Slim
Smalltalk
Snap
Spark
Spider-Gazelle
Spincast
Spock
Spring
Swagger
SWI-Prolog
Swift
Symfony2
Symfony4
Vert.x
VRaptor
web.py
Yesod

Implementations

filter by tag

aiohttp Akka API Platform Axon Framework Azure Functions Azure SQL CakePHP Catalyst Ceylon Clear Clojure CoffeeScript Compojure Couchbase CouchDB Crystal C# Django .NET Dropwizard Elixir ES6 express.js Finatra Finch Fintrospect Flask Flyway F# Gin Go kit Golang GORM GraalVM Gradle Grape gyokuro Hanami Hapi.js Haskell Hexagon http4k immutant Java Java EE Javalin JavaScript JDBI Jersey Jodd Jooby JVM Kemal Kitura Knex.js Koa Koin Kotlin Ktor Lagan Laravel lift LittleBoxes luminus mangoo I/O maru Masonite Micro Micronaut Mojolicious MongoDB Nancy NDatabase NeDB Nim node.js nutzboot OCaml OWIN Perl Pharo Phoenix Framework PHP Play! plumber Postgres Python Quarkus Rails Ratpack Redis redux Reitit restify Rocket R Ruby Rust Scala Scotty Seaside Servant ServiceStack Sesame Sinatra Slim Smalltalk Snap Spark Spider-Gazelle Spincast Spock Spring Swagger SWI-Prolog Swift Symfony2 Symfony4 Vert.x VRaptor web.py Yesod

.NET 6 / Clean Architecture

This is an implementation of the todobackend to demonstrate (or even use as a template) for .NET Clean Architecture projects.

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 / Azure Functions / Azure SQL

Todo backend implemented with Node and Azure Functions. Database is Azure SQL.

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 / Express / Knex.js

Node.js + Express + Knex (query builder configured to save to Postgres). Implementation uses async/await. Courtesty of Tony Cheang.

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.

TypeScript / Node.js / Hapi.js

Node.js example using the Hapi framework and saving to memory.

Node.js / Micro / Postgres

Node.js example using the Micro framework.

Node.js / SailsJS

Node.js implementation in SailsJS by Kix Panganiban.

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.

Golang / Echo

A Golang implementation using the Echo web framework, courtesy of Simar Kalra.

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

Scala / Akka / Swagger

The akka-http framework. The Scala language. Swagger to specify the API and Twilio Guardrails to generate the code.

Kotlin / Http4k

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

Kotlin / Rapidoid

Kotlin + Rapidoid, saving im-memory.

Kotlin / Ktor / Koin

Implementation using Kotlin, Ktor and Koin, saving in-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.

C# - with DDD & EventSourcing

C# with DDD approach. State is persisted via EventSourcing and an in-memory event store.

Golang / stdlib

A Golang implementation using only the standard libraries

Golang / stdlib / Makefile

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 by Kix Panganiban.

Python / Sanic

Implementation written in Sanic by Kix Panganiban.

Python / Molten

Implementation written in Molten by Kix Panganiban.

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.

Scala / endpoints4s / Swagger

A Scala implementation using endpoints4s to also describe the API with Swagger UI. Under the hood: http4s and doobie.

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.

Crystal / Spider-Gazelle / Clear ORM / Postgres

A Crystal implementation using Spider-Gazelle framework, Clear ORM and PostgresDB.

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.

Kotlin / Ktor

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

Kotlin / Hexagon

Kotlin + Hexagon, saving 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.

F# - Giraffe

Implementation using Giraffe in F# by mabe. Items are stored in memory.

Clojure with Luminus and Immutant

Implemented in Clojure using Luminus and Immutant.

Java 8 with Java EE 8

Java 8 implementation running on the Java EE 8 compatible Payara Micro as a microservice. ToDos are in-memory.

Ruby / Hanami

A Ruby implementation using Hanami.

Ktor / Kotlin

Implementation using Ktor by Gopinath Langote. Items are stored in memory.

Python / Masonite

Implementation using Masonite by Kentaro Matsuzaki.

Java 11 / Spark / JDBI / no annotations

A Java 11 implementation using the Spark framework. Persistence to Postgres using JDBI. No Java annotations.

Scala / ZIO, http4s

Todo-Backend (https://www.todobackend.com/) implementation using ZIO, http4s and circe

Pharo / Seaside

Implementation for the todo backend using Pharo and Seaside.

Java / Micronaut

Implementation using Micronaut. Items are stored in memory H2.

PHP / CakePHP 4

PHP implementation with CakePHP 4.

Java - Spring Boot 2

Implementation using Spring Boot, Gradle as the build tool, and a Postgres database with migrations managed by Flyway. By Brian Sayler.

Kotlin / Hexagon, MongoDb

Implementation using Kotlin and Hexagon saving items to a mongoDb database

PHP / Symfony4 with api-platform

PHP implementation with Symfony 4, using API Platform.

ASP.NET Core 3.1 / Couchbase

A todo backend written in C# with ASP.NET Core 3.1 and Couchbase Server 6.5 as a backend.

R / Plumber

A todo backend written in R with Plumber.

Javalin / Java 11

A Java 11 implementation using the lightweight and fast Javalin framework.

Quarkus

A Quarkus implementation using the Quarkus framework. RESTEasy/JAX-RS and JSON-B extensions and Persistence to Postgres using Hibernate ORM with Panache extension PANACHE.

Node.js / NeDB / Express

Nodejs using embbeded database NeDB. Feel free to follow Mauricio Lobo.

Erlang / Cowboy

Erlang implementation using cowboy framework and mnesia for storing data

Golang / Go kit / GORM

An example implementation with Go kit, GORM and PostgreSQL.

Clojure / Reitit / next-jdbc

A simple Clojure implementation storing to Posgres DB via next.jdbc courtesy of Mike Salihi.

Golang / Go kit

A Golang implementation using Go kit, following Modern Go Application practices.

Golang / mux / buntdb

A Go implementation using mux and BuntDB.

Crystal / Spider-Gazelle / Clear

A Crystal implementation using Spider-Gazelle with Clear ORM and PostgreSQL

{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.