diff --git a/src/lambda.zig b/src/lambda.zig
new file mode 100644
index 0000000..6d7e262
--- /dev/null
+++ b/src/lambda.zig
@@ -0,0 +1,486 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const HandlerFn = *const fn (std.mem.Allocator, []const u8) anyerror![]const u8;
+
+const log = std.log.scoped(.lambda);
+
+var empty_headers: std.http.Headers = undefined;
+var client: ?std.http.Client = null;
+
+const prefix = "http://";
+const postfix = "/2018-06-01/runtime/invocation";
+
+pub fn deinit() void {
+    if (client) |*c| c.deinit();
+    client = null;
+}
+/// Starts the lambda framework. Handler will be called when an event is processing
+/// If an allocator is not provided, an approrpriate allocator will be selected and used
+/// This function is intended to loop infinitely. If not used in this manner,
+/// make sure to call the deinit() function
+pub fn run(allocator: ?std.mem.Allocator, event_handler: HandlerFn) !void { // TODO: remove inferred error set?
+    const lambda_runtime_uri = std.os.getenv("AWS_LAMBDA_RUNTIME_API") orelse test_lambda_runtime_uri.?;
+    // TODO: If this is null, go into single use command line mode
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const alloc = allocator orelse gpa.allocator();
+
+    const url = try std.fmt.allocPrint(alloc, "{s}{s}{s}/next", .{ prefix, lambda_runtime_uri, postfix });
+    defer alloc.free(url);
+    const uri = try std.Uri.parse(url);
+
+    // TODO: Simply adding this line without even using the client is enough
+    // to cause seg faults!?
+    // client = client orelse .{ .allocator = alloc };
+    // so we'll do this instead
+    if (client != null) return error.MustDeInitBeforeCallingRunAgain;
+    client = .{ .allocator = alloc };
+    empty_headers = std.http.Headers.init(alloc);
+    defer empty_headers.deinit();
+    log.info("tid {d} (lambda): Bootstrap initializing with event url: {s}", .{ std.Thread.getCurrentId(), url });
+
+    while (lambda_remaining_requests == null or lambda_remaining_requests.? > 0) {
+        if (lambda_remaining_requests) |*r| {
+            // we're under test
+            log.debug("lambda remaining requests: {d}", .{r.*});
+            r.* -= 1;
+        }
+        var req_alloc = std.heap.ArenaAllocator.init(alloc);
+        defer req_alloc.deinit();
+        const req_allocator = req_alloc.allocator();
+
+        // Fundamentally we're doing 3 things:
+        // 1. Get the next event from Lambda (event data and request id)
+        // 2. Call our handler to get the response
+        // 3. Post the response back to Lambda
+        var ev = getEvent(req_allocator, uri) catch |err| {
+            // Well, at this point all we can do is shout at the void
+            log.err("Error fetching event details: {}", .{err});
+            std.os.exit(1);
+            // continue;
+        };
+        if (ev == null) continue; // this gets logged in getEvent, and without
+        // a request id, we still can't do anything
+        // reasonable to report back
+        const event = ev.?;
+        defer ev.?.deinit();
+        const event_response = event_handler(req_allocator, event.event_data) catch |err| {
+            event.reportError(@errorReturnTrace(), err, lambda_runtime_uri) catch unreachable;
+            continue;
+        };
+        event.postResponse(lambda_runtime_uri, event_response) catch |err| {
+            event.reportError(@errorReturnTrace(), err, lambda_runtime_uri) catch unreachable;
+            continue;
+        };
+    }
+}
+
+const Event = struct {
+    allocator: std.mem.Allocator,
+    event_data: []u8,
+    request_id: []u8,
+
+    const Self = @This();
+
+    pub fn init(allocator: std.mem.Allocator, event_data: []u8, request_id: []u8) Self {
+        return .{
+            .allocator = allocator,
+            .event_data = event_data,
+            .request_id = request_id,
+        };
+    }
+    pub fn deinit(self: *Self) void {
+        self.allocator.free(self.event_data);
+        self.allocator.free(self.request_id);
+    }
+    fn reportError(
+        self: Self,
+        return_trace: ?*std.builtin.StackTrace,
+        err: anytype,
+        lambda_runtime_uri: []const u8,
+    ) !void {
+        // If we fail in this function, we're pretty hosed up
+        if (return_trace) |rt|
+            log.err("Caught error: {}. Return Trace: {any}", .{ err, rt })
+        else
+            log.err("Caught error: {}. No return trace available", .{err});
+        const err_url = try std.fmt.allocPrint(
+            self.allocator,
+            "{s}{s}{s}/{s}/error",
+            .{ prefix, lambda_runtime_uri, postfix, self.request_id },
+        );
+        defer self.allocator.free(err_url);
+        const err_uri = try std.Uri.parse(err_url);
+        const content =
+            \\{{
+            \\  "errorMessage": "{s}",
+            \\  "errorType": "HandlerReturnedError",
+            \\  "stackTrace": [ "{any}" ]
+            \\}}
+        ;
+        const content_fmt = if (return_trace) |rt|
+            try std.fmt.allocPrint(self.allocator, content, .{ @errorName(err), rt })
+        else
+            try std.fmt.allocPrint(self.allocator, content, .{ @errorName(err), "no return trace available" });
+        defer self.allocator.free(content_fmt);
+        log.err("Posting to {s}: Data {s}", .{ err_url, content_fmt });
+
+        var err_headers = std.http.Headers.init(self.allocator);
+        defer err_headers.deinit();
+        err_headers.append(
+            "Lambda-Runtime-Function-Error-Type",
+            "HandlerReturned",
+        ) catch |append_err| {
+            log.err("Error appending error header to post response for request id {s}: {}", .{ self.request_id, append_err });
+            std.os.exit(1);
+        };
+        // TODO: There is something up with using a shared client in this way
+        //       so we're taking a perf hit in favor of stability. In a practical
+        //       sense, without making HTTPS connections (lambda environment is
+        //       non-ssl), this shouldn't be a big issue
+        var cl = std.http.Client{ .allocator = self.allocator };
+        defer cl.deinit();
+        var req = try cl.request(.POST, err_uri, empty_headers, .{});
+        // var req = try client.?.request(.POST, err_uri, empty_headers, .{});
+        // defer req.deinit();
+        req.transfer_encoding = .{ .content_length = content_fmt.len };
+        req.start() catch |post_err| { // Well, at this point all we can do is shout at the void
+            log.err("Error posting response (start) for request id {s}: {}", .{ self.request_id, post_err });
+            std.os.exit(1);
+        };
+        try req.writeAll(content_fmt);
+        try req.finish();
+        req.wait() catch |post_err| { // Well, at this point all we can do is shout at the void
+            log.err("Error posting response (wait) for request id {s}: {}", .{ self.request_id, post_err });
+            std.os.exit(1);
+        };
+        // TODO: Determine why this post is not returning
+        if (req.response.status != .ok) {
+            // Documentation says something about "exit immediately". The
+            // Lambda infrastrucutre restarts, so it's unclear if that's necessary.
+            // It seems as though a continue should be fine, and slightly faster
+            log.err("Get fail: {} {s}", .{
+                @intFromEnum(req.response.status),
+                req.response.status.phrase() orelse "",
+            });
+            std.os.exit(1);
+        }
+        log.err("Error reporting post complete", .{});
+    }
+
+    fn postResponse(self: Self, lambda_runtime_uri: []const u8, event_response: []const u8) !void {
+        const response_url = try std.fmt.allocPrint(
+            self.allocator,
+            "{s}{s}{s}/{s}/response",
+            .{ prefix, lambda_runtime_uri, postfix, self.request_id },
+        );
+        defer self.allocator.free(response_url);
+        const response_uri = try std.Uri.parse(response_url);
+        var cl = std.http.Client{ .allocator = self.allocator };
+        defer cl.deinit();
+        var req = try cl.request(.POST, response_uri, empty_headers, .{});
+        // var req = try client.?.request(.POST, response_uri, empty_headers, .{});
+        defer req.deinit();
+        const response_content = try std.fmt.allocPrint(
+            self.allocator,
+            "{{ \"content\": \"{s}\" }}",
+            .{event_response},
+        );
+        defer self.allocator.free(response_content);
+
+        req.transfer_encoding = .{ .content_length = response_content.len };
+        try req.start();
+        try req.writeAll(response_content);
+        try req.finish();
+        try req.wait();
+    }
+};
+
+fn getEvent(allocator: std.mem.Allocator, event_data_uri: std.Uri) !?Event {
+    // TODO: There is something up with using a shared client in this way
+    //       so we're taking a perf hit in favor of stability. In a practical
+    //       sense, without making HTTPS connections (lambda environment is
+    //       non-ssl), this shouldn't be a big issue
+    var cl = std.http.Client{ .allocator = allocator };
+    defer cl.deinit();
+    var req = try cl.request(.GET, event_data_uri, empty_headers, .{});
+    // var req = try client.?.request(.GET, event_data_uri, empty_headers, .{});
+    // defer req.deinit();
+
+    try req.start();
+    try req.finish();
+    // Lambda freezes the process at this line of code. During warm start,
+    // the process will unfreeze and data will be sent in response to client.get
+    try req.wait();
+    if (req.response.status != .ok) {
+        // Documentation says something about "exit immediately". The
+        // Lambda infrastrucutre restarts, so it's unclear if that's necessary.
+        // It seems as though a continue should be fine, and slightly faster
+        // std.os.exit(1);
+        log.err("Lambda server event response returned bad error code: {} {s}", .{
+            @intFromEnum(req.response.status),
+            req.response.status.phrase() orelse "",
+        });
+        return error.EventResponseNotOkResponse;
+    }
+
+    var request_id: ?[]const u8 = null;
+    var content_length: ?usize = null;
+    for (req.response.headers.list.items) |h| {
+        if (std.ascii.eqlIgnoreCase(h.name, "Lambda-Runtime-Aws-Request-Id"))
+            request_id = h.value;
+        if (std.ascii.eqlIgnoreCase(h.name, "Content-Length")) {
+            content_length = std.fmt.parseUnsigned(usize, h.value, 10) catch null;
+            if (content_length == null)
+                log.warn("Error parsing content length value: '{s}'", .{h.value});
+        }
+        // TODO: XRay uses an environment variable to do its magic. It's our
+        //       responsibility to set this, but no zig-native setenv(3)/putenv(3)
+        //       exists. I would kind of rather not link in libc for this,
+        //       so we'll hold for now and think on this
+        //        if (std.mem.indexOf(u8, h.name.value, "Lambda-Runtime-Trace-Id")) |_|
+        //            std.process.
+        // std.os.setenv("AWS_LAMBDA_RUNTIME_API");
+    }
+    if (request_id == null) {
+        // We can't report back an issue because the runtime error reporting endpoint
+        // uses request id in its path. So the best we can do is log the error and move
+        // on here.
+        log.err("Could not find request id: skipping request", .{});
+        return null;
+    }
+    if (content_length == null) {
+        // We can't report back an issue because the runtime error reporting endpoint
+        // uses request id in its path. So the best we can do is log the error and move
+        // on here.
+        log.err("No content length provided for event data", .{});
+        return null;
+    }
+    const req_id = request_id.?;
+    log.debug("got lambda request with id {s}", .{req_id});
+
+    var resp_payload = try std.ArrayList(u8).initCapacity(allocator, content_length.?);
+    defer resp_payload.deinit();
+    try resp_payload.resize(content_length.?);
+    var response_data = try resp_payload.toOwnedSlice();
+    errdefer allocator.free(response_data);
+    _ = try req.readAll(response_data);
+
+    return Event.init(
+        allocator,
+        response_data,
+        try allocator.dupe(u8, req_id),
+    );
+}
+
+////////////////////////////////////////////////////////////////////////
+// All code below this line is for testing
+////////////////////////////////////////////////////////////////////////
+var server_port: ?u16 = null;
+var server_remaining_requests: usize = 0;
+var lambda_remaining_requests: ?usize = null;
+var server_response: []const u8 = "unset";
+var server_request_aka_lambda_response: []u8 = "";
+var test_lambda_runtime_uri: ?[]u8 = null;
+
+var server_ready = false;
+/// This starts a test server. We're not testing the server itself,
+/// so the main tests will start this thing up and create an arena around the
+/// whole thing so we can just deallocate everything at once at the end,
+/// leaks be damned
+fn startServer(allocator: std.mem.Allocator) !std.Thread {
+    return try std.Thread.spawn(
+        .{},
+        threadMain,
+        .{allocator},
+    );
+}
+
+fn threadMain(allocator: std.mem.Allocator) !void {
+    var server = std.http.Server.init(allocator, .{ .reuse_address = true });
+    // defer server.deinit();
+
+    const address = try std.net.Address.parseIp("127.0.0.1", 0);
+    try server.listen(address);
+    server_port = server.socket.listen_address.in.getPort();
+
+    test_lambda_runtime_uri = try std.fmt.allocPrint(allocator, "127.0.0.1:{d}", .{server_port.?});
+    log.debug("server listening at {s}", .{test_lambda_runtime_uri.?});
+    defer server.deinit();
+    defer test_lambda_runtime_uri = null;
+    defer server_port = null;
+    log.info("starting server thread, tid {d}", .{std.Thread.getCurrentId()});
+    var arena = std.heap.ArenaAllocator.init(allocator);
+    defer arena.deinit();
+    var aa = arena.allocator();
+    // We're in control of all requests/responses, so this flag will tell us
+    // when it's time to shut down
+    while (server_remaining_requests > 0) {
+        server_remaining_requests -= 1;
+        // defer {
+        //     if (!arena.reset(.{ .retain_capacity = {} })) {
+        //         // reallocation failed, arena is degraded
+        //         log.warn("Arena reset failed and is degraded. Resetting arena", .{});
+        //         arena.deinit();
+        //         arena = std.heap.ArenaAllocator.init(allocator);
+        //         aa = arena.allocator();
+        //     }
+        // }
+
+        processRequest(aa, &server) catch |e| {
+            log.err("Unexpected error processing request: {any}", .{e});
+            if (@errorReturnTrace()) |trace| {
+                std.debug.dumpStackTrace(trace.*);
+            }
+        };
+    }
+}
+
+fn processRequest(allocator: std.mem.Allocator, server: *std.http.Server) !void {
+    server_ready = true;
+    errdefer server_ready = false;
+    log.debug(
+        "tid {d} (server): server waiting to accept. requests remaining: {d}",
+        .{ std.Thread.getCurrentId(), server_remaining_requests + 1 },
+    );
+    var res = try server.accept(.{ .allocator = allocator });
+    server_ready = false;
+    defer res.deinit();
+    defer _ = res.reset();
+    try res.wait(); // wait for client to send a complete request head
+
+    const errstr = "Internal Server Error\n";
+    var errbuf: [errstr.len]u8 = undefined;
+    @memcpy(&errbuf, errstr);
+    var response_bytes: []const u8 = errbuf[0..];
+
+    if (res.request.content_length) |l|
+        server_request_aka_lambda_response = try res.reader().readAllAlloc(allocator, @as(usize, l));
+
+    log.debug(
+        "tid {d} (server): {d} bytes read from request",
+        .{ std.Thread.getCurrentId(), server_request_aka_lambda_response.len },
+    );
+
+    // try response.headers.append("content-type", "text/plain");
+    response_bytes = serve(allocator, &res) catch |e| brk: {
+        res.status = .internal_server_error;
+        // TODO: more about this particular request
+        log.err("Unexpected error from executor processing request: {any}", .{e});
+        if (@errorReturnTrace()) |trace| {
+            std.debug.dumpStackTrace(trace.*);
+        }
+        break :brk "Unexpected error generating request to lambda";
+    };
+    res.transfer_encoding = .{ .content_length = response_bytes.len };
+    try res.do();
+    _ = try res.writer().writeAll(response_bytes);
+    try res.finish();
+    log.debug(
+        "tid {d} (server): sent response",
+        .{std.Thread.getCurrentId()},
+    );
+}
+
+fn serve(allocator: std.mem.Allocator, res: *std.http.Server.Response) ![]const u8 {
+    _ = allocator;
+    // try res.headers.append("content-length", try std.fmt.allocPrint(allocator, "{d}", .{server_response.len}));
+    try res.headers.append("Lambda-Runtime-Aws-Request-Id", "69");
+    return server_response;
+}
+
+fn handler(allocator: std.mem.Allocator, event_data: []const u8) ![]const u8 {
+    _ = allocator;
+    return event_data;
+}
+fn test_run(allocator: std.mem.Allocator, event_handler: HandlerFn) !std.Thread {
+    return try std.Thread.spawn(
+        .{},
+        run,
+        .{ allocator, event_handler },
+    );
+}
+
+fn lambda_request(allocator: std.mem.Allocator, request: []const u8, request_count: usize) ![]u8 {
+    var arena = std.heap.ArenaAllocator.init(allocator);
+    defer arena.deinit();
+    var aa = arena.allocator();
+    // Setup our server to run, and set the response for the server to the
+    // request. There is a cognitive disconnect here between mental model and
+    // physical model.
+    //
+    // Mental model:
+    //
+    // Lambda request -> λ -> Lambda response
+    //
+    // Physcial Model:
+    //
+    // 1. λ requests instructions from server
+    // 2. server provides "Lambda request"
+    // 3. λ posts response back to server
+    //
+    // So here we are setting up our server, then our lambda request loop,
+    // but it all needs to be in seperate threads so we can control startup
+    // and shut down. Both server and Lambda are set up to watch global variable
+    // booleans to know when to shut down. This function is designed for a
+    // single request/response pair only
+
+    lambda_remaining_requests = request_count;
+    server_remaining_requests = lambda_remaining_requests.? * 2; // Lambda functions
+    // fetch from the server,
+    // then post back. Always
+    // 2, no more, no less
+    server_response = request; // set our instructions to lambda, which in our
+    // physical model above, is the server response
+    defer server_response = "unset"; // set it back so we don't get confused later
+    // when subsequent tests fail
+    const server_thread = try startServer(aa); // start the server, get it ready
+    while (!server_ready)
+        std.time.sleep(100);
+
+    log.debug("tid {d} (main): server reports ready", .{std.Thread.getCurrentId()});
+    // we aren't testing the server,
+    // so we'll use the arena allocator
+    defer server_thread.join(); // we'll be shutting everything down before we exit
+
+    // Now we need to start the lambda framework, following a siimilar pattern
+    const lambda_thread = try test_run(allocator, handler); // We want our function under test to report leaks
+    lambda_thread.join();
+    return try allocator.dupe(u8, server_request_aka_lambda_response);
+}
+
+test "basic request" {
+    // std.testing.log_level = .debug;
+    const allocator = std.testing.allocator;
+    const request =
+        \\{"foo": "bar", "baz": "qux"}
+    ;
+
+    // This is what's actually coming back. Is this right?
+    const expected_response =
+        \\{ "content": "{"foo": "bar", "baz": "qux"}" }
+    ;
+    const lambda_response = try lambda_request(allocator, request, 1);
+    defer deinit();
+    defer allocator.free(lambda_response);
+    try std.testing.expectEqualStrings(expected_response, lambda_response);
+}
+
+test "several requests do not fail" {
+    // std.testing.log_level = .debug;
+    const allocator = std.testing.allocator;
+    const request =
+        \\{"foo": "bar", "baz": "qux"}
+    ;
+
+    // This is what's actually coming back. Is this right?
+    const expected_response =
+        \\{ "content": "{"foo": "bar", "baz": "qux"}" }
+    ;
+    const lambda_response = try lambda_request(allocator, request, 5);
+    defer deinit();
+    defer allocator.free(lambda_response);
+    try std.testing.expectEqualStrings(expected_response, lambda_response);
+}