diff --git a/backend/src/models/order.rs b/backend/src/models/order.rs
index a72c706..34a7ab9 100644
--- a/backend/src/models/order.rs
+++ b/backend/src/models/order.rs
@@ -21,8 +21,9 @@ pub struct OrderUpdate {
 
 #[derive(Debug, Deserialize, Serialize)]
 pub struct OrderCreate {
-    pub invoice_number: String,
-    pub customer_id: Uuid,
+    invoice_number: String,
+    customer_id: Uuid,
+    batch_ids: Vec<Uuid>,
 }
 
 impl Update<Order> for OrderUpdate {
@@ -53,38 +54,106 @@ impl CrudBackend for Order {
     }
 
     async fn create_inner(conn: &mut PgConnection, create: Self::Create) -> Result<Self> {
-        todo!()
+        let order = sqlx::query_as!(
+            Order,
+            "INSERT INTO orders (invoice_number, customer_id) VALUES ($1, $2) RETURNING *",
+            create.invoice_number,
+            create.customer_id
+        )
+        .fetch_one(&mut *conn)
+        .await?;
+
+        for batch_id in create.batch_ids {
+            sqlx::query_as!(
+                Batch,
+                "INSERT INTO order_items (batch_id, order_id) VALUES ($1, $2)",
+                batch_id,
+                order.id
+            )
+            .execute(&mut *conn)
+            .await?;
+        }
+
+        Ok(order)
     }
 
     async fn read_inner<'a>(
         conn: impl sqlx::prelude::Executor<'a, Database = sqlx::Postgres>,
         id: Self::Identifier,
     ) -> Result<Self> {
-        todo!()
+        sqlx::query_as!(Order, "SELECT * FROM orders WHERE id = $1", id)
+            .fetch_one(conn)
+            .await
+            .map_err(Into::into)
     }
 
     async fn update_inner(&mut self, conn: &mut PgConnection) -> Result<()> {
-        todo!()
+        sqlx::query_as!(
+            Order,
+            "UPDATE orders SET invoice_number = $1, customer_id = $2 WHERE id = $3 RETURNING *",
+            self.invoice_number,
+            self.customer_id,
+            self.id
+        )
+        .fetch_one(conn)
+        .await
+        .map_err(Into::into)
+        .map(|order| *self = order)
     }
 
     async fn delete_inner(&self, conn: &mut PgConnection) -> Result<()> {
-        todo!()
+        sqlx::query_as!(
+            Order,
+            "DELETE FROM orders WHERE id = $1 RETURNING *",
+            self.id
+        )
+        .fetch_one(conn)
+        .await
+        .map_err(Into::into)
+        .map(|_| ())
     }
 }
 
 impl Order {
     pub async fn add_batch(&mut self, conn: &mut PgConnection, batch_id: Uuid) -> Result<()> {
-        todo!()
+        sqlx::query!(
+            "INSERT INTO order_items (batch_id, order_id) VALUES ($1, $2)",
+            batch_id,
+            self.id
+        )
+        .execute(&mut *conn)
+        .await
+        .map_err(Into::into)
+        .map(|_| ())
     }
 
     pub async fn remove_batch(&mut self, conn: &mut PgConnection, batch_id: Uuid) -> Result<()> {
-        todo!()
+        sqlx::query!(
+            "DELETE FROM order_items WHERE batch_id = $1 AND order_id = $2",
+            batch_id,
+            self.id
+        )
+        .execute(&mut *conn)
+        .await
+        .map_err(Into::into)
+        .map(|_| ())
     }
 
     pub async fn get_items<'a>(
         &self,
         conn: impl sqlx::prelude::Executor<'a, Database = sqlx::Postgres>,
     ) -> Result<Vec<Batch>> {
-        todo!()
+        sqlx::query_as!(
+            Batch,
+            "
+            SELECT batches.*
+            FROM batches
+            INNER JOIN order_items ON batches.id = order_items.batch_id
+            WHERE order_items.order_id = $1",
+            self.id
+        )
+        .fetch_all(conn)
+        .await
+        .map_err(Into::into)
     }
 }