Met up with Steve on the morning meeting. Steve has been on vacation for a couple of weeks. We spent some time doing some catch-up and planning. We jumped right in and started looking over ideas and plans for the upcoming training event.

- Steve's idea - Ground zero - adilas training - Start at the very beginning.

- Keep it simple - $100 per day

- Part of the event should focus on where we are going and where we are seeing the concepts and trends heading. These are things like world building, 3D data assembly line, and the adilas model.

- Steve really wants us to focus on the adilas model. Share the "Why". Show what we have learned and why that works. Help to enable them to think and build on their own solutions. Teach the why and the how. Teach them to play like we want to play.

- Show a demo of what we are thinking and planning on the upcoming mini conversion project.

- Steve was talking about how much the event would bring to us vs how much it costs to put it on. Tons of benefits. Let's help push things forward.

After Steve and I got done brainstorming, Dustin S. (new developer) came on and we helped him get up to speed on Git and Bit Bucket. Steve and Dustin then worked together on some state API tracking stuff. I left the meeting and did some email stuff.

On the morning meeting with Steve and Russell. They were talking about how Bridgerland could help with outside development and doing smaller projects. Part of the puzzle is how we empower our users. It is so important to empower our users at the level that they need (go to the source). That is a huge core concept.

Taking the email options out to the bulk level and also allowing users to make the email come from their own servers.

As the guys were talking, I was doing some research on the old adilas website. Lots of good PDF files, help files, graphics, and flyers. Here is the old website link: https://data0.adilas.biz/old_index.cfm

Eric wants to talk about coupons and loyalty points. We talked about a guy named Chris Johnnie and some prior planning that may have been done by Russell and Chris. We are trying to pull things together and make everything happen.

From Eric - It is so expensive to keep stopping and starting - we lose tons in the transitions. We need to focus and stay on track.

Eric was expressing some concerns about sub inventory on the production side of things. Steve chimed in and was talking about how some people don't even know what else is possible and already built. The trail is faint and many people have been gone in different directions. We need to define the best path and then help educate others to play the game.

Manufacturing is a whole new level - You have raw goods being made into finished goods. Lots of internal flipping and tweaking. You need bill of materials, sub assemblies, recipes, other tracking needs, etc. We talked briefly about parent inventory and sub or child inventory. Some of the big needs come when they have sub assemblies and use semi raw goods and then push it into another finished good or product. You have to be at the sub level in order to really track that information. It gets into sub locations and sub phases and all kinds of other subs. In the background, we are seeing the _Z coordinate (depth and stacking) coming more in to play.

We are having a number of clients that are fighting against change. Some of the subjects are the way the one-to-many relationships are setup and what the individual people think should be the best option. Some of the questions are things like - one PO with multiple line items or one PO per one line item. Which one holds the location and how do you move things around. They want to group things but also be able to move things independently. They need both... basically, I'm part of this group but I also play over here and here. Very interesting.

This is a side note, but we end up spending so much time managing our customers because they all want to chime in and say what they feel is the best. Custom is awesome but it can also get us in trouble. Custom is really easy on existing and established pieces. One of the main problems is when we get into uncharted territory, people have all kinds of ideas and what things would work best. Once the trail is set and people are using it, they tend to go with what is already there unless we make it too hard. When the trail is not fully established, it turns into the wild west (anything goes) really quickly.

Once people get what they want, they tend to want to get to it quicker. They also want more. This could be more options, more control, more access, more of almost everything. They basically get addicted to data and ease of use.

Steve was doing a demo on sub phases, sub groups, and sub locations. Lots of using elements of time and special flags and tags to track all of the details.

One thing that will help people is showing them how to get back to their details and data. We (developers and power users) know things well enough that we pop through screens, skip steps, and go really fast. A new user is watching and they just get lost. So many moving pieces. It hasn't been smoothed out and/or standardized yet to really make it manageable and easy to understand. We either need to slow down and/or make the path more direct and discernible. Make it obvious and straight forward.

A note for us... We can use these subs to hold the sub details and sub data. We need to show things in very general levels and make it look simple unless the user wants to get clear down to the lower detail level. Think of the world building graphics that have universe level, world level, location level, group level, individual level, and the underlying data level. We need to allow the users to navigate at whatever level they feel most comfortable. We need all of the deep, deep, sub data, but that may be too much detail for some people and/or users.

There will be a greater and greater needs for mini conversions and how that effects things. Steve has already done quite a bit of work on the custom/build_complex_labels.cfm page. We need to use that as a great starting place. Lots of moving pieces. It goes like this... You have to have a parent item. Parents have subs or children. Those children then get broken down into smaller pieces and sub packaged. That is mini conversions.

We keep pioneering small little projects and getting some testers and people who keep pushing on things. Adilas is literally a giant testing environment and a virtual idea farm. We keep planting and harvesting ideas. They just keep coming.

Going back to manufacturing - there are tons of batches, sub batches, lots, and even reprocessing and repackaging pieces. We need to keep defining the road and helping the people who will be coming down the road later on. Kinda like Eric was saying... We need to focus and get pieces done and standardized - we get pulled in so many different directions. We lose a ton in the transition and switchover between projects. It gets very expensive and takes a ton of time and energy. In manufacturing, they often will set up an assembly line for a certain run... They then run that product until it is done. If they had to switch lines (assembly lines) every couple of hours, they would have tons of down time. Maybe we need to do similar type things. Make a plan and then work your plan.

The other gem is using the people who know it... get the reps and the clients together that know what is going on.

Flow - We can link all kinds of stuff together. That is a whole other level. If we can get the job done and get the person to the correct next step, we can help them keep moving forward. It comes down to flow and planning. Steve wants Dustin to help with some of that flow. Steve's words... "we need to train the system". That helps the whole thing go better. Dustin's words were... "the system almost needs rails". They then talked about wizards, steps, and showing a logic path and where they are on that legend or helping them know what is next and where things are at. Walk them through it. This could be crumb trails, legends, wizards, etc. Good stuff.

Steve and I were talking about system setup options. We would like to add another system setup that has ecommerce... Here are some of the rough numbers: The normal easy system setup $989 + $100 ecommerce setup (one-time fee) + $100 ecommerce training + $67 ecommerce monthly = $1,256

Russell popped in for a bit and had a couple of questions. Steve was helping Dustin with some code changes. I was building new graphics for the easy system setup items. Good stuff.

See attached for a number of graphics that are out in the adilas ecommerce site.

On the morning GoToMeeting session with Steve, Russell, and Dustin. We chatted a little bit about the upcoming training, Russell had me working in the WordPress news and updates section. I then helped Dustin with some complex data objects and getting structures and arrays figured out. I was on the phone helping Bryan with SSL issues, helping Russell with some settings, and working more on a GEO tourism flyer for the training event. I was also going through a small to do list for an upcoming data migration. Checking servers and making sure things are in order. I still have a few loose ends for that project to go through smoothly.

Russell and Steve were talking about the power of the adilas API sockets and how to tap into that market. Kinda like WordPress and other open source options. If we build it and make it available, other developers can then use it through the adilas API sockets. The concept of "Play at the Wall".

Brandon wanted me to add some notes, this is Russell Moore. As mentioned above we are talking about the possibility for third-party solutions as well as full Corporation solutions running off of the adilas API. One of the other subjects we were talking about was to design the inside of adilas with a constant html structure, so that every time we decide to change the look and feel, it can be done as easily as possible. Somewhat like the concept of CSSZenGarden.

Helping Steve and Dustin with what they are doing. Steve was working with a custom wire job for elements of time and Dustin was working on combining structures and arrays to make complex data objects.

Spent some time working on the data 8 server and making sure we could get into things there. Submitted some tech support tickets to get some files and folders copied between servers for a migration project. Also worked lightly on the adilas training event and image. The WordPress news and updates was doing something funky on the image and the way it was cropping it.

On the morning meeting. Russell checked in and we pointed him in the direction of API sockets and helping to train the new developers. Dustin and I worked on a small project to fix and show the sub connections on the time sub special flags and tags. We needed to tie-in the app types, main id's, sub id's, and table names. We worked through the project in somewhat of a training type scenario. I had fun, coded, answered questions, drew little sketches, showed pictures, and Dustin followed right along. Great session.

Working on the custom code part of in-line dollars off for the in-line discounts project.

Part way through, I met up with Steve and Dustin and helped them fix some merge conflicts on their branches. We got everything merged in and pushed to the live servers.

Russell came in and reported to Steve and Dustin about his news and update settings and multiple WordPress feeds. We then did some light planning on who was going to teach what for the upcoming training event. Lots of emails and planning.

Calvin popped in and reported on some new updates in GPS land. He has a phone provider that is offering GPS tracking with an API from a standard phone carrier and provider. That is awesome and will help simplify the process of getting the GPS data. He also gave us a small demo of his adilas label builder program.

Part way through the demo, we had to do some emergency surgery and fix a problem with the WordPress news and updates feed. It was looking for an image but one hadn't been uploaded yet, it was stopping all new logins. If you were already on, you were good, but it you were just logging in, it would block you by showing an error message. We had to tweak a few files and got everything all up to date and ready to go. Kinda crazy.

More emails and light tech support stuff.

On the morning meeting with Steve and Dustin. I merged in some code from their branches. Wayne popped in and showed Steve and Dustin a small demo on what he is doing to help rewrite some of the Metrc stuff. He loves to rewrite things and make it look more simple. After that, Steve gave Wayne a demo on his cultivation process that he is working on. Good stuff.

Alan and I spent the last half of the session working on in-line discounts and doing some deeper testing. We were testing and making notes on bugs or light fixes that were needed. Excellent back and forth checking, debugging, recording, and testing. It made the testing so much more fun to have two eyes on the same tasks. We'll do this again.

Live Adilas Class. Logan, UT - Bridgerland ATC, Custom Fit, Room 810 (computer lab). We had 4 live paying clients and a number of internal team members in the class. We had Steve, Shari O., Dustin S., Alan, Bryan, Calvin, Russell, Shawn, Jeremiah, and myself from the core adilas team. Not all of them were there everyday, all the time, but they all came and participated quite a bit of the time. We also had a number of folks join us online in the GoToMeeting sessions. We recorded all of the training except for two main sessions.

Here are some links to the videos.

video from day 1 - morning session
small adilas demo, intro, and core concepts

video from day 1 - afternoon session
new features, open q&a, and historical stepping stones

video from day 2 - morning session
POS - point of sale features part 1

video from day 2 - afternoon session
POS - point of sale features part 2 - open q&a, and world building in use

video from day 3 - morning session
CRM - customer relationship management overview

video from day 3 - afternoon session
exploring ecommerce & custom email settings - BI - business intelligence and big data

video from day 4 - morning session
tips, tricks, & best practices - small custom consulting session

video from day 4 - afternoon session
meet the adilas developers, adilas model, and wrap-up

///////////////////////////////////////////////////////////////
other notes that I took during the class.
5/29/18
- Drag and drop custom fields - they really like the custom field settings for customers. They would love that to cascade out and filter through the whole system. Point and click, toggle on/off fields, sort, customize verbage & instructions, and be able to effect the display as well.

- The need for more one-to-many relationships

- Light request for more settings on the main salesperson and other salesperson settings - be able to split the names instead of just one setting.

- A custom preset on permissions "copy and/or duplicate" permissions.

- Setup a master and then apply those settings. This could be templates and/or master files - a virtual job description.

- Floating up and down nav to help minimize the scrolling.

- The power of "templates" - elements of time, sub inventory, payee/users, look & feel, etc.

- Start by setting up the templates and then assign them as needed - that makes a great starting point.

5/3018
- Alan was doing an exercise - he had everybody list what they could for two minutes on all of the fruits that they could think of. Fun little exercise. After that, he was comparing this to development. We try to hit the fruit that is on your list. Things keep evolving and sometimes you forget things and have to add that in later.

-  Corp-wide settings and allowing you to set certain verbage stuff.

- Bryan Dayton was showing the adilas market (adilas world). We really need to get others into the marketplace.

- While Bryan was showing his profile... I was thinking that we need to help him get some better screen shots for his demo graphics. You could tell that they were done with a low end and/or free graphic editor (kinda fuzzy and pixelated).

- It helps us to have a flow and/or a clear picture (talking about custom code and custom development).

- Small demo on a custom dashboard for Global Design

- Steve and Shari O. were talking and doing a demo together. Steve was talking and Shari O. was driving. Later Steve and I did similar things. It really helps to split that load and have a helper. The person talking can focus on what they are saying and the demo person (driver) can draw, highlight things, and show focus areas. It seemed to work out quite well.

- Steve and Shari O. started out in a coffee shop and did some quick split cart stuff. They then went into some of the corp-wide settings to show how they were able to do what they were doing. Good flow from normal usage to how it is done based off of settings.

- Eventually we need a deep merge (find and replace) on customer records.

- Our users would like to be able to compound a discount. For example: double up points, do a 1.5 mark-up, etc. Lots of time based sales and promotions.

5/31/18
- Not many notes from this day... We started out and Steve and I were presenting on sub inventory. See the video links above for more details and info.

6/1/18
- Steve was going over the new cultivation functionality. 4 main levels for the cannabis guys... they need cultivation, production, distribution, and retail.

- Some of the these white label options should really build out and use all of the pieces.

- Page and function level settings

- Interesting topic of hardcoding & concepting vs dynamic code & production - speed, limited scope, and testing.

- Being able to lock-down certain pieces, features, and virtually ice things down (ice-down dates).

- Also, interesting as we get deeper and deeper into the industry specific code... the verbage, lingo, & the flow are really important. That is what makes it feel like native or custom code or custom software.

- Comment from Dustin - We need guide rails, guard rails, settings, templates, and easy configuration options. Help lead the people down the paths that we want them to go.

- On the data tables - it sure would be cool if you could sub filter things. It comes down to space, coding, page real estate, and planning. People want more and more custom options - to setup their flow, work space, and environment (requests for deeper and more robust world building options).

- On numeric entry fields, show the unit of measure to remove the questions (if applicable).

- Making the label options show up and be available from multiple pages and such.

- Settings are preset choices & decisions - super important.

- On Calvin's tools... Just an idea, but what about dynamic or user input boxes and text fields? This is for text that may be added on the fly. He currently has static text, HTML enabled text fields (allows formatting), and dynamic look-up text (text fields mapped to data or dynamic output). What about user input text boxes?

- Making labels and empower the users.

- We had a client/participant that recommended that we put a small icon on each page that could be a default homepage and then have a quick link to set it as the default homepage. Great idea. Basically, let them navigate there (to the actual page) and then set it as their homepage if that is what they want.

/////////////////////////////////////////////////////
Comments from Bryan - who talked with one of the participants

- When starting the class, for someone who is brand new... it might be nice to give a 15-20 intro and general overview. We just started out and jumped right in. Basically, somewhat of a canned explanation of what is adilas and what do you get with this software package. A really simple and organized intro.

/////////////////////////////////////////////////////
Notes from Dustin - See attached for full notes

General To Do's:

Need to Have each page check for the color of the background and adjust the card to be a lighter complimentary color (universal). (4,5)

Need to have api key capability for each employee that performs metrc api interaction.

Need to set up custom permission setting capabilities so that they can set permissions for multiple employees over time without having to do a redundant process. Themes and standardized user type templates.

Make a excel or csv spreadsheet that templates the fields needed for api integration to give to a customer to fill out. Maybe a master list that passes in all of the general fields and passes over unneeded fields based on customer needs.

Need a graphical repesentation of the entire seed to sale process with tie-ins to each adilas feature/tool.

Need predictive on the search vendor field on the add/edit page.

Need to have customer password fields auto-populate wherever needed. (e-commerce)

Need to have a set to default button on the nav menu for setting any page as a default homepage.

Need to have a toolbar button for page relevent tips and tricks with links to news and updates.

Need to update how people reset thier login attempts: lets add a captcha or at least put the copy paste link on the same page. Maybe two step varification would work.

When you are switching corps, instead of needing to click on the little box link, make it so that you can click on anywhere on the corp piece.

Need to have UOM type indicators on any field that holds wieghts. In most cases this could probably be hard coded.

Need to create the ability to check a box that opens all of the subs for inventory search for adding to cart.

Joined the morning meeting. Briefly checked in with Steve, Alan, Russell, and Dustin. I was uploading photos and scans for a data migration while going through emails and what not. Doing small to do list stuff to try to get somewhat caught up on things. Uploading video files from the training event, recording notes from training, and entering bills and such.

See element of time # 3699 for tons of notes and video links from the live training event.

Pushed up code to allow people to get to the live training event videos. Recording more notes and such. Reading over some notes that I got from Dustin that he took from the training event. Good stuff.

Joined the morning GoToMeeting session. Russell, Steve, Dustin, and Alan were on. We did some light code sign-off for Russell, Steve and Dustin had a couple of questions, and we mostly just worked. I was doing captcha images for our contact us email form to help with security. A captcha image is an image that has letters and numbers, randomly displayed as part of the graphic. The goal is to make it human readable but harder for a machine due to the random spacing, angles, and font faces on the image. The theory is to lessen the chance that a robot or bot is submitting the contact us form.

Talking about creating a smaller sub theme in adilas and called it "fracture". This would end up being an adilas fracture account. We would like to rebuild things from the virtual ground up and add in all of the subs of subs and database field level control. This would be a full on internal white label and/or internal theme that goes down to the micro level. This deals with database field names, settings, permissions, and all of the sub settings and sub permissions that are needed. It could also deal and use smaller getters and setters as well as individual databases, custom API access levels, etc.

This is kind of a dream, but it would be so cool if we took the time to virtually rebuild the entire thing from the ground up and use and apply all of the ideas and lessons that we have learned getting to this point. That would be really exciting. It would really be cool if we had the money, funding, plan, and people and talent assets ready to play the game as well. That would be a huge but awesome project. Just an idea and/or a dream at this point in the game.

Talking about scalability and how to manage up and down swings without shooting ourselves in the foot. We were talking about load balancing and monitoring usage, storage, and bandwidth.

We have been seeing some light push back on price from the consultants. Basically, they are charging a certain amount and then promising that our services are and/or will be a certain rate for life.

We are also seeing that some of our clients are growing as they come on to our systems. That is hard to know what is going to happen when they first start up.

Technology keeps changing and pushing things forward. This is a crazy world and we need to build on the dynamic changing environments that happen all the time. This is not a static model.

Traditionally, software companies build versions and then release that version. They then build in the background and make the next version and then plan the release of the next version. Our model is literally build and deploy on a daily, weekly basis. Alan was saying that our clients are paying for what the current adilas system does and can do... they are not paying for the future developments. However, some of the client demands are almost all speed, bulk, and future related.

Tons of cause and effect relationships, pros and cons, and maintenance things... lots of talk about concepts, styles, and preferences.

After our discussions, we all went back and worked on our own projects. I was working on adding in the customer type id filter for sales tax reports and advanced invoice searches. Steve and Dustin were working on Metrc API pieces and bulk QR code labels. We also had both Wayne, Alan, and Calvin pop in and help with different questions and projects. Busy work section. Also some light phone calls and tech support stuff.

Talking about people and how to organize and plan the projects that are needed. Lots of talking about putting people in play where they can shine best.

We did some code merging for Steve's and Dustin's branches.

Jumped back on with Steve and Dustin. Light flex grid tie-in training for Dustin and showing him how to get some of the data back that he was looking for. We ended up creating a spreadsheet and looking at the flex grid tie-in stuff in super simple form and format. Good session.

On the morning meeting with Steve and Dustin. I spent some time getting back into the developer's notebook project. We are trying to get some our brainstorming and info out to the world so that we can protect things like business or 3D world building, business or 3D data assembly line concepts, and other core adilas concepts and pieces. There will eventually be tons of different options, as far as code and application features go, but we really want to protect and help educate the general public about the core concepts and pieces that we are built upon. That is a huge part of the goal.

Helping Dustin get some custom labels going and helping to populate them. We had to fix a number of small coding issues. Good learning session.

On the morning meeting. Steve was talking with some white label guys and talking numbers, sales, and options. It was fun to listen in from the background. Bryan jumped on and we did some code tweaks for some new invoice and cart rounding options. We pushed up files and did some testing. We found a small error and made a quick fix. We only got a couple of calls and we mostly were able to sneak pass the error without anybody knowing there was a problem. Everything should be good to go now.

Steve was saying that Alan said - "We sell our clients a system that does x, y, and z for a price and they are happy. Then a couple months later they want p, d, and q for the same price. That is not a standard software model. Normally, software creates a version, sells it, and then works on the next version. If you want the next version, you have to pay for it. We are somewhat working on a continuous release type model. It feels like we are trying to work on a car or truck as it is rolling down the road at 50 to 60 miles an hour. Pretty crazy.

Talking about options for bulk editing tools. We talked about being able to edit things on a one-by-one basis, bulk editing, short cuts, and also a matrix type interfaces. It is very interesting that as we paint the picture more and more, better and better, other people can see and catch the vision. They start helping to push us to faster and faster and encourage us to be more efficient, and have better flow. Pretty crazy, client feedback driven type functions and models. It almost leads itself, if you will let it.

I was working more on the developer's notebook project and getting photos, scans, and images ready to go. I also started to work on the media/content (uploaded files) pieces and getting that sub section tied in.

Towards the end of the session, I helped Dustin with some custom cart labels and where and how to get the data to populate the custom PDF labels.

Light talks about big data and fully tracking all sales clear out to the state, county, and city level. It is amazing how much the word "tax" or "taxes" play into the mix. Lots and lots of changes.

What if we built the application to help record the sales tax information so that it could be world wide. This would have to be on a per transaction basis. We already do this on stock/units and stamp the current tax rates, taxes, and customer location per stock/unit purchase. We also have some built-in functionality where an invoice could be sold from one location and then flipped to a different location and thus changing the full sales tax pieces.

We also talked about some of the underground and black market pieces that will come from some of these choices and decisions. Huge requirements usually drive certain people to a more hidden and/or underground market. Kinda interesting.

This whole conversation is part of what is going on. We at least need to know and acknowledge that some of these changes are going on.

Eric popped in and we switched to talking about loyalty points. One of his main questions was, are we using a line item to lower the total of the cart (redemption points) or are we using some kind of special payment type for loyalty points? Great questions. Eric came back in later and we spent some time talking about line items vs special payment types. What is a loyalty point? Is it a special account that doesn't really play into the financials or does it? Are the redemption of loyalty points a virtual discount or does it affect an actual liability that is recorded somewhere on the financials? Eric is using cart favorite buttons to help setup some of these systems.

We are seeing that most of the people want a standard value for the loyalty point. Some people have wanted variable point values. One of Eric's main question is dealing with the difference between how to accumulate and redeem the loyalty points. Is it a line item or is it a special account or special payment type. We are seeing special payment types coming more into the mix. Are loyalty points a real liability or are they a phantom liability? What happens if the loyalty points are variable? Does that mean that the phantom costs of that liability can change?

We also talked about special tracking accounts... Are these real, like a gift card or are they virtual or phantom like a loyalty point? They could potentially play slightly different. One of the challenged are wanting loyalty points having variable values based on time (dates and times) and/or what is going on in the cart (certain sales, promotions, or campaigns). The variable changing loyalty points could be a problem in tracking what the phantom liability is.

Maybe we could track all loyalty points and gift card stuff in the special tracking accounts. We then allow for the main account types to be real and/or phantom based. That way we could pull a real asset, liability, and/or equity account or a simulated (fake and/or phantom) asset, liability, or equity account. We really need to track all of the in and out values. Then we need to record what happens as those items are used. There may be a point value and a dollar value. They may even be different based on time. The value of time is going to be playing more into the mix on how these points are going to be used. Interesting, the loyalty points are becoming a form of currency and we need to figure out how to apply that. It goes beyond a simple discount and gets into an additional payment type. In a way, the question is what is the value of the loyalty points? Is it a discount or a payment type? We are seeing that people want to have both and even mix things to make it feel like the deal is even better.

We may need some tools that allow them to set things up and then the system will play by the rules that they setup. We need ways to add/edit loyalty points through a virtual interface. Everything needs to be tracked on the special tracking accounts. We can add (manual or automated) and we could subtract from the virtual account through both manual and automated action.

What if we allowed the users to setup the rules if they are using line items to add and subtract on an invoice or if they are using special payment types and how that affects things. Basically, we build the tools that are very generic and flexible and then help the users setup their own goals, needs, rules, and usage options.

After that, we jumped in and worked with both Steve and Dustin on merging in their code branches.

Popped in to the afternoon GoToMeeting session. Dustin and I chatted about a possible conference room in the Denver Tech Area. I worked on the developer's notebook pages and being able to show media/content as part of the pages. I also did some emails and phone calls. Light tech support.

Dustin, Alan, Wayen, and I were on the morning meeting. Small demo by Wayne on object oriented coding. We were seeing all kinds of service objects, data objects, database access objects, and other models. This all goes back to the keeping the data, the validation, the business logic, and the database stuff all on different levels. That just makes the code more re-usable and more logical to follow (both internal and external). All of this makes things more modular and easy to use.

We spent a little bit of time talking about MVC's (model view controller). Each area is different. You have the model, the view, and the controller piece. They are all kept separate and run on their own levels. You can then mix them as needed. We talked about DAO's (data access objects) and using universal getters and setters to get at the data and the sub pieces of those concepts.

The guys were getting into what will and won't work and why. They were talking trade-offs of simplicity vs flexibility and other factors. Other topics ranged clear out to security, XSS (cross site scripting), SQL injections, etc. They were talking about transactional records, commits, roll-backs, try/catches, and other safety measures. They were talking table level locking, application flow, traffic, scalability, and usability.

They were talking about unit tests, global testing, and other pieces. Standalone tests, mock-ups, and sequence tests. Having their testing already ready and done really helps them to go in and change things with confidence. Test driven design and getting that peace of mind, knowing that you have a number of prebuilt and preselected tests to run on your old and new code. It is a real time saver and helps them have the confidence that things are working, even with changes.

We are changing the implementation (how things are done) vs the background core principles (why or what is being done). Pretty technical discussion. These guys are masters and are good at what they do.

We are trying to get the entire application out to the web/API socket level. We need a way to structure things and yet have modular data and open access to all.

After the demo/meeting we all split up and worked on our own projects. Steve, Alan, and Wayne kept working on some Metrc plant code. I was working on the developer's notebook project. Then after that, we jumped into a discussion about servers, virtual servers, and how to help optimize the different servers. We were talking heap sizes, through put, and other optimizing and server asset management options.

On the morning meeting. Wayne popped in and wanted to get permission to setup a server to help monitor the other servers. We talked about it and decided to let him setup a server on AWS (amazon web services) to monitor our other servers. He will build things out and then report back to us on the progress. Basically, that allows us to experiment without jumping in hook, line, and sinker.

We spent a good portion of the meeting going over code, options, and answering questions. Back and forth between myself and Steve. We also talked quite a bit about optimizing database and queries. Light tech support to help Steve, Dustin, and Bryan. Around 11 am, Bryan popped in and we worked on a server primary domain mapping issue so that new and/or white label custom domain names could work with the adilas.biz application. Made some tweaks and pushed up new code.

Emails and other tech support stuff.

Steve, Dustin, and I were all on the morning meeting. I was working on the developer's notebook pages and project. Currently working on a page that shows web ready (public entries) elements of time in a grid type breakdown by month and year. The goal is to help web spiders and other web crawlers to be able to get to the elements of time and then index and archive the content easier. This is a big part of the developer's notebook project.

Our underlying goal is somewhat of an attempt to help publish and publicize some of the core concepts that adilas.biz is build on. Going way back, we went to a workshop on intellectual property and how to patent, copyright, trademark, etc.  As part of that, they said that if there was prior art or prior work, you couldn't do the patents, copyrights, and trademark stuff. So, in a way, we are trying to make some of the core concepts become part of the public knowledge bank. We are basically trying to make it so that the core concepts are unable to be patented or trademarked. We need them to be open and available for all entities.

Wayne popped in and he showed us some server monitor stuff using a Nagios server. We setup some server monitors for all known servers.

Morning work session. Helping Steve with some code to show the top 15 customers and then saving the settings to populate some of the retail homepages based off of the top 15 customers. Bryan came on and had a few questions about some of the new servers that are being setup. We had to go in and work on some dates and default pieces for the new server setup process. Both Dustin and I were working on our own projects as well.

On the morning meeting with Steve, Dustin, and Wayne. Steve and Wayne were working on a bunch of different things and updates to Metrc stuff (state compliance API calls). I was answering emails, light tech support, and checking on random bugs.

On the morning GoToMeeting session with Steve, Dustin, Wayne, and Alan. We were all working on different projects. Alan and I were primarily working on in-line discounts and making sure that the new excise tax calculations were playing well. Lots of back and forth debugging. Wayne and Steve were working on new Metrc plants, packages, and cultivation stuff. They were working through a small date issue with the databases. Lots of testing and micro tweaks on all sides. It was also nice to have another pair of eyes for the different projects. Sometimes Alan was helping Steve or Wayne or I was helping Steve or Wayne. Lots of back and forth, all using the same meeting. Good session.

Working through bugs, issues, and such. Helped Dustin with some JavaScript. Also working with Alan on in-line discounts and dollars off discounts. We made some final tweaks and pushed up code on the data 0 box (live) and did some testing. We then pushed up files to all servers. An hour or so after the big push, we got a few emails and texts saying that certain companies were having problems. We spent the rest of the session and afternoon chasing bugs and making small fixes. We tried to get what we could, but a few little ones got past us. Not too bad for majorly tweaking the entire shopping cart engine and discount options. :)

Jumped on the morning meeting with Steve and Dustin. We briefly talked about some topics for the upcoming Denver training (9/11 to 9/14) Some of the recommended topics were things like: new cultivation processes, production and packaging processes, Metrc Specific topics, new sales tax stuff, new discount stuff, normal and advanced POS (point of sale) stuff, ecommerce, my cart favorite buttons, sub inventory, labels, loyalty points, etc.

We also talked about getting the graphical homepages into place and even starting with sales tax and invoice homepages. We would also like for the adilas developers to be able to present to us while in Denver... (merging in technology and live classroom stuff).

People who could help out: Cory from Pagosa Springs, Kelly Whyman, Steve Mitchel, Shannon, Russell, Alan, and other adilas developers.

After talking, we broke into a work session type scenario. We were all working on our own projects. I went back to working on the developer's notebook stuff and showing the historical listing of elements of time (for web indexing and web crawlers). We got back together for random questions throughout the morning session.

On the morning meeting with Steve and Dustin. We mostly worked on our own projects. I was pushing up some code and changes for the adilas developer's notebook project. I made some small navigation changes and tried to make sure that the pages could be viewed with both a valid login (set session look and feel) as well as just normal generic look and feel. I then spent some time looking around and browsing some of the older entries. Talk about a trip down memory lane. Good stuff.

Checked in to see if anybody needs some help. Mostly out of the office all week. Talked with Dustin about some sub filtering of prep queries (working with smaller record sets) and then some form submission and JavaScript stuff. Going through emails and text messages. Talked with Eric and setup some times to work on the loyalty points project. Called and chatted with Shari O. and Steve. Just touching base. Tech support and other random to do list stuff.

Met up with Steve and Dustin over the morning meeting. I was prepping things for a big data migration between servers. Dustin was working on his settings page. We went over some options and goals for his current project and worked together for a bit. Later on in the meeting, Steve was asking a report about labels and what is going on there. I made a call to Calvin and got a small update. We decided to meet around 1 pm to chat and talk about progress.

After that, Steve and I got on a phone call and talked about where we are going and some internal direction for how we want to deal with developers, budgets, and developer rates. We are seeing that some of the high-end developers are doing the external jobs for a much higher rate than we can offer internally. That is awesome if they get the work. Not so good for us, because our projects get lowered on the priority scale. By us paying them monies that they haven't even earned yet, we may be hurting ourselves. Imagine if you had monies coming in and adding up for work to be done, but you knew that it was less per hour. It then becomes a pain in order to get back to that because you know that the net value of that money is less than what you could earn somewhere else. It almost becomes a thorn in your side vs a positive pick-me-up. Anyways, we had a good conversation and tried to come up with some plans.

We have two bigger, higher-end developers, that we may need to pay their normal commercial rate and stop sending them residual monies. Kinda refactor things and help them fly at there normal commercial rate. That may help get our project back to the top of the priority pile. Interesting concept.

On the morning meeting with the guys. Bryan and I used up the first 45 minutes wrapping up where we were at on the application flex grid planning. Wayne popped in and reported. He has been sick for a few days/weeks. He will be helping out with a server to server migration project later tonight. We also talked about an existing project of inter-migrating data between two fully running servers. That is very deep and is actually a C sharp project (server-side software). Very deep.

Steve and I worked with Dustin and tried to help him on his mapping and custom dynamic settings page. We had to go back in time (on the code) and look-up some older values. They still existed, they had just been renamed and it made it hard to figure out if we were still talking and dealing with the same pieces.

Steve and I talked about how in-depth it would be to do a full server to server migration while the systems are up and being used. We went clear back to a project (world building) that started with Highland Vineyard and wanting a full duplicate copy of a corporation so that an older owner could have their data and the new buying company could have their own data. We have had a need here for a long time. It is totally unknown and might end up being a super huge project ($150,000+ level).

At the end of the meeting, Eric popped in to work on the loyalty point and such. We are going to get back together after lunch.

Jumped on the morning meeting. Steve and Dustin were on there and so was Wayne. Steve and Dustin opened up a Zoom session and worked on that. Wayne and I worked on a huge database field list with tables, field names, and mapping out of the foreign keys (database columns that link tables together in a relationship). We went over 4,000+ fields during our meeting. Most of the time was spent mapping out what foreign key values where and how they mapped to what primary tables and columns. We saw lots of activity in the payee (users and vendors) table as well as the corporations (worlds or business companies). Good session.

At the end of the session, Wayne showed me a sneak peak at a tool he is calling the Adilas Database Sync tool. It is a C sharp program that compares two different databases and makes sure that they are all synced up. I got excited on a few of the cool and creative features. Here is a small list. For more info, talk and ask Wayne for a demo.

- Super cool idea for comparing records... He would put all of the data together in a huge string (column value, column value, column value, etc.). He would then run a quick hash on that data. A hash makes a small 32 character unique code (really small amount for storage). He could then store that hash value. Then later on, when he was checking the data, he could put all the new data together and re-hash it. If the hashes matched (the two small hash values), no updates were needed and he could skip the record. If the new hash was different than the old hash, he would run the update that know what fields to update. This helps sync the data and also allows the system to skip something that doesn't need any changes. Very cool.

- He setup the whole thing to do non-destructive adding and updating based on using recursive functions (building logic as needed vs doing a, then b, then c). He also built in some options for taking care of the exceptions.

- This new Adilas Database Sync tool will have a huge time savings attached to it. Just a day or so ago, we migrated over 12,000,000+ records for a server to server migration. With Wayne's tool, we could set it up to do the sync even days before the actual migration process. It could run while you sleep and even run over days and days as needed. Then, when you are ready to do the final migration (deep pass over the data), most of the work would already be done and only new updates, additions, and/or changes would need to take place. That is huge. This also opens up possibilities of doing some mirroring and having back-up data servers. Very cool.

- We talked about using this database sync tool for doing for testing... We could copy over specific customer data, code against it, do the tests, and then go from there. Huge options.

- We briefly talked about Calvin's Auto Process Tool and custom code options there. Once again, both of these programs use server-side software to get major crunching power while still allowing for a normal web-based interface. Imagine what we could do if we built some connections between Calvin's auto process tool  and Wayne's adilas database sync tool.

- We talked about how developing server-side software using something like C sharp is so much faster than web-based languages. We talked about how many levels of conversion the code goes through and/or does in order to run it... Imagine ColdFusion code being interpreted by Java and Java be interpreted who knows what, and that being interpreted into system or unit code, etc. You get the idea. There is also a huge difference in the timeout windows and how long process are able to run without manual and/or user interactions.

- We could schedule out long running tasks, report, exports, and/or other tasks. We could get away from web session timeouts. That would be awesome. Sometimes it feels like we are trying to fit the whole world through a revolving door (analogy of trying to hit the web timeout rules).

- We could also use some of the C sharp tools to flip indexes and database column level defaults. Some of these things are text fields currently set to latin 1, could be changed to UTF-8 format. We could change default dates and times from default dates of 0000-00-00 to 1990-01-01 (a real date value vs the generic placeholder) and default times from 00:00:00 to 12:00:00. Once again, we could skip all of the web session timeouts and just get the job done. All good things and it could be done very quickly with minimal clicking and babysitting. That is where the value lies. Good stuff.

Looking forward, I'm not sure what the future holds, but I'll bet that it will have both web code, server-side software, API sockets, and other hybrid type solutions. Each thing is good at a part of the game, we just need to mix and blend as needed to get the different jobs done. Exciting times ahead.

On the morning meeting with Steve and Dustin. Alan popped in for a bit and gave us an update. We talked about the upcoming Denver training event in the first part of September. Made a few plans. Light debugging on Dustin's code and then on to other projects. Tons of emails to go through. Spent some time reworking a flyer for the training event. Steve and Dustin were working on their own projects most of the session.

On the morning meeting with Steve and Dustin. We had to check in on data 1 and do a server reset. Steve and I chatted about plans for using the managed care offered by Newtek (the server guys) and/or doing our own thing and allowing some of our people to remote in and reset the servers. We also talked a little bit about splitting up databases and the pros and cons of doing such (world building project).

Tons of emails and going through things. I've been gone for a couple of days and there were hundreds and hundreds of emails to go through. Lots of junk, but a few that need some attention.

Wayne popped in and we talked about database transfers between servers and how to handle duplicate records. We came up with a plan and he will be moving forward with the plan.

Eric and I setup some dedicated times to work on loyalty points and special account tracking. We are planning on 2 hour blocks for the next two weeks, from 1-3 pm, Tuesday, Wednesday, and Thursday. That will be good to get some dedicated times to work on things.

------ different topic -----

These were some other questions that I wrote on a number of post-it notes... we are just trying to get organized and figure out a better plan for handling all of the pieces that are coming in.

- There are so many needs

- There are so many new requests (new things)

- There are quite a few bug requests (old things)

- Who does the work?

- How do we inform them?

- What is the plan?

- How can we duplicate ourselves?

- How do we create the funnel type approach.... things come in, we record them, we organize them, we distribute them, we work on them, we can check in, get reports and put things to bed

- If I add to my to do list... it never gets done

- Who can I use and what are my budgets?

- How do you prioritize request, projects, and bugs?

- Who gets assigned?

- What do we want to be?

- What are we becoming?

- Who are we wearing out?

- How do we mange that?

- What are our goals?

- We need some help

- See a need... fill a need - I kept coming back to this... this may be the next step.

- Help people manage themselves

- I feel like I'm climbing with a dresser on my back - so many pieces, we need to simplify.

- What teams (people assets) do we have? How are we going to use that?

- I'm running and hiding...

- We need some help

- Kinda like facing giants

- Get the Lord's help

- Get some good help

- See a need, and then fill that need... make a plan!

- Focus on one thing at a time - it is hard to switch and transition.

- We may have to keep people at bay while we do things.

- Schedule it out and stick to that if possible.

------- meeting with Steve -----

- Departments and who gets what

- We sometimes have multiple people looking and checking on the same things. That is not effective and/or efficient. Say an email that is sent to Steve and I, we both look at it and then both respond. This is just one example.

- How do things come in? Do they start with support or do they start with a call to a rep or something else? We might need to start catching things and then funneling them around.

- There is not a book on "SaaS" Software as a Service. We are kinda faking it as we go. That is for real. Basically a pioneering project.

- Maybe talk to Shannon and see if we could get here back. Maybe have her come back in as a different role. We could really use an internal project manager of sorts. Maybe a higher or overall approach.

- We may need to use elements of time and create our own support system and/or support tickets. That could be really quick, now that we have some things ready and done.

- We would love to have a sorted tick list... What are the top 10 maintenance pieces, top 10 bugs, top 10 new requests, top 10 upcoming projects. Then keep rotating through that.

- We love the concept of the data assembly line... What about our new needs... We have done of data, tons of servers, tons of requests, tons of needs... how are we going to track that process and take the actions that are needed.

- We might need places where we have ideas, projects, maintenance, bugs, etc.

- We often talk about the burning platform... it is amazing as we keep going, the burning platforms get fixed, and then there becomes another burning platform.

- Steve and I need a shield to help us filter some of the outside static and/or noise. Once it gets boiled down, we could get a list of things to do and work on.

- We feel bad about not being able to get emails, phone calls, and texts. We are just getting too many. We may need a person to help shield us a bit there.

- Steve and I have thousands and thousands of emails and thousands and thousands of text messages. It gets too much for one person to handle.

- We are in the business of data management, storage, processing, and such. We need to help categorize things and help filter the number of requests that come in.

- Filters... We need someone to help us catch things and then basically boil things down into a manageable list.

- We need to be able to allocate resources as we see fit. There are always limits on people, talent, time, money, etc. We need to manage our resources.

- We have some guys that are top notch... We are seeing Wayne, Alan, Eric, Bryan, Will, Dustin, etc. They are all shining and showing more and more potential. That is exciting.

- We also have Shari O., Shannon, Drea, etc. on the tech support and customer care side.

- We will be working on a running list and trying to be more effective.

- We really want to reach out and have the people run and excel where they have skills and talents.

- We are going to be reaching out to and contacting some of our people. We have a great team... if we use that team wisely, that will open up options.

- Kinda funny, we use to ask our clients, where is your pain? Let's start there. We'll we have the pain now, so, I guess we start there and work forward. Yee haw!

Small pow-wow on what happened with the server hack, light debriefing and recap, where we are going, and how to push usernames and passwords to other developers. Making a small plan to push out resources to the different developers.

Calvin came in and we were chatting about the upcoming adilas training in Denver as well as bulk texting (GMext program) and text alerting (more strategic but smaller text messages). Lots of needs and options coming down the pipeline. One of Calvin's comments was the cost in multi texts is in the texts. The cost in alerting is in the code and how to make those triggers and where to place those pieces of code.

We also spent some time talking about the adilas label builder and how that will all play out. Calvin and I were documenting steps and processes to get it all rolled out. We spent a lot of time talking about the order process (what do you want), how we can assign it, how we then request it, and how to actually process and print that label. We also lightly talked about how to communicate back and forth between the different servers. Lots of moving pieces and lots of data going back and forth.

The end goal is to get a custom label solution that is owned and used by adilas for the adilas clients. We want to keep building onto the overall solution and/or platform. Sometimes, we have to build stepping stones and then try to link them together to make up the bigger picture. Lots of mixing and blending of pieces and concepts. Another interesting piece of the puzzle is the question, how are things being used? Sometimes the feedback that we get and when we can see the usage patterns, that is like gold to a developer. If we let our users, they will help tell and show us where we need to go and how to get there. They, our users, are a huge resource.

Spent some time helping Dustin get his settings page dialed in. He is making one of his first, both add and edit, pages that uses the same page. Lots of his logic is modern div tags and JavaScript vs normal page modes and physical page refreshes. He was on it and will do fine.

Meeting with Shannon and Steve about a new possible role for Shannon working with the main adilas team. We started out and Shannon gave us a small report on little Hyrum and being a new mommy. Good stuff.

- Maybe help hide Shannon from the general public.

- We would love to have Shannon still help with some tech support stuff, but on a higher level. Kinda a upper level or overseer of sorts.

- We would like to have Drea keep doing customer support and news and updates. Drea has been very helpful with Metrc type questions.

- Light talks about tech support and even allowing a blog and/or forum to help users get answers to their problems.

- We have some people in place to help us out with some of the news and updates. We could use Benjamin, Drea, Dustin, and Janna.

- We could expand the news and updates into more of a tech support type level. Just an idea. This is a WordPress site and we could tie-in to that as a prebuild piece.

- Even with the WordPress blog, we still get a lot of spam that needs to be filtered out.

- We need some help categorizing, prioritized, and then delegating things out.

- Currently, both Brandon and Steve and not very proactive (due to our load). We could really use someone to help us become more proactive and looking where we want to go.

- Once we get a bank of questions and answers, we could then use that more as a response vs re-writing solutions after solutions.

- We would love to keep branching out to other business verticals. We are hoping to get a good team that could handle certain industry-specific needs and then allow us to keep expanding into different verticals and different industries. That would be really cool. As a side note, we do need people on staff that can play well in the different industries.

Got on the meeting early to work with Steve and Alan. They were looking into some server issues with the data 5 box. Alan was on the box and Steve was browsing through the web. They were running checks and looking at things. Most of the corporations were doing fine, the problem was with one of the bigger ones. It seemed to be at the database level. If a super huge query was being ran, it was clogging up the queue to run other database queries. Alan ended up looking into temp table sizes, heap sizes, and max levels of memory that were available. He made some small modifications and we fully rebooted the server. When it came back up, it seemed to be running much faster. Alan then went to all other servers and adjusted database max levels to match the new settings. In a small way, this is just part of the performance tuning that needs to happen. Basically, you run into a wall, figure it out, and try to expand the corridor.

Shari O. popped in and we had to look into a small issue on the data 1 box. Alan was on the box and we had a table that had locked itself. We did some repairs and were able to get the table back up and running.

Wayne popped in and had a few questions. Dustin then worked with Alan to get some JavaScript rounding errors taken care of. Alan and I then started to look into the sales tax updates for other tax 6 through other tax 10 (new custom tax fields). This is one of the final steps in the sales tax changes that we were making earlier this year.

On the morning meeting with Steve and Dustin. We merged in both of their code branches and pushed a few new files up to all servers. Calvin popped in and reported on his local hard drive and getting it recovered... good reminder for all of us to keep doing local back-ups. Alan came on and helped with questions and then he and I went over the Denver training schedule. Alan is doing some performance tuning on some of the servers and some of the most used queries. We talked about getting access to bigger data sets to run the queries against for testing and to see the real costs (against the database) with the bigger data sets. Small plans and talking about indexing certain tables, columns, and combo columns in the database.

Called and touched base with Shari O. about the Denver training event. She will be doing a couple of sections and also talking about who is covering food and snacks. She is awesome and wonderful helper.

9009 E Arapahoe Road, Greenwood Village, CO 80112
Phone: (303) 799-4555

See attached for notes, scans, files, and GoToMeeting recordings (videos)

--------------------------------------

Day 1

We did some intros and then got started. Danny Shuford did a demo and did a great job. See attached for some notes. Here are a couple of the highlights from what I took away from it.

- Solution for solution minded people

- It can be molded to fit your industry

- Changes keep happening

- Big open view of the whole system - it wasn't made for just one industry

- Brief overview of the framework

- Based on user permissions and valid logins

- All web-based and cloud-based

- Features and benefits - focusing on the benefits

- CRM - log notes, additional contacts, photos, and other media

- We all deal with money, but in the end... we are all dealing with people

- Note to me... Danny went into the customer table and doing the custom page settings on the customer fields. This is for things like the name, aliases, sort value, show/hide, etc. We really need to keep pushing that idea and concept forward. People really want that level of control. It just takes a ton of work to cascade that through the full system.

- He talked about news and updates

- "Our Interface" - what do you want? We don't have a single set interface, we let you choose

- Customer queue

- Lots of moving parts

- Drea - "Adilas is play dough"

- Inventory tracking

- Reporting and building your own reports

- Labels and changes to the requirements

- ecommerce

- Payroll

- Accounts payable and accounts receivable

- Print checks

- emails

- Customize and working with the developers

- Security and back-ups

- Steve - Showing some hidden gems

- Small demo on flex grid

Next, I gave a small section on the adilas model - core concepts - and intro to world building. I will upload my outline. I'm also hoping to upload the video as well. I don't have any notes because I was the presenter, but here is my rough outline:

- We will be bouncing around

- Start with a guy holding tons of stuff

- Talk about the needs and how to organize things

- Go over different tools... head and mind, paper and pencil, word processing, spreadsheets, databases, software packages, web or hosted solutions

- Go over systems and how things start to inter-relate

- Cover the 12 main players

- Cover the 12 business functions

- Cover the 12 main world building concepts

- Mix and blend to get the desired results

After lunch, Alan Williams did a presentation on highlighting and exploring new features. He started out with a fun group activity and a game of sorts. Minimal communication and we had to figure out a path through a virtual mine (bomb) field. It ended up having forward steps, side steps, back steps, etc. We eventually, as a group, got through the mine field. Really fun exercise and it opened up some conversations. Here are some notes from Alan's presentation:

- Little active - mine field - group activity - finding their way

- How does this relate to the adilas process?

- He then showed some of the steps that we have taken to build the application

- Side steps, back steps, and forward steps

- Going into advanced add to cart and sub functions

- Request from the group - no standalone discounts - Make that a permission and/or a setting. Standalone discounts can and do cause tax problems.

Next, Steve Berkenkotter lead an open Q & A section. The first question was asking about any updates with the Metrc (state compliance and tracking system for Colorado). That got pretty deep but exposed some of the challenges that exist between connecting and maintaining dual systems (adilas and Metrc). Here are a few notes:

- Questions on Metrc

- Some new tables and new limits from Metrc

- Auto processors - running nightly stuff to help sync data between systems

- API and server to server connections

- Challenges that exist

- Mixing old and new functionality

- Transfers

- Sales

- Using elements of time to track states, status, phases, and groupings

- Getting back at the data - reporting

- High level vision

- Question from Pat - 280E - new tax and accounting rules - what can we write off as cost of goods? What about unitizing expenses?

- Steve - How the IRS is looking at things and expecting things

- Steve - loves numbers and how he brings his skills to the table

- Work in progress - attributing a value as part of the accounting

- The progression of building and breaking

- The system is able to store the data (huge piece of the puzzle)

- The system may be customized to get the data back out and/or to get the data in (another huge piece of the puzzle)

- Template building

- A consultant spending time and configuring a system before it is released to the end users

- Small questions on CSS and changing certain page colors

The last section of the day was a presentation on historical stepping stones - what have we learned and why do we do what we do? I did this presentation so I will add my outline. Once again, we are hoping to get some videos uploaded to this element of time incase someone wants to watch the videos. Here was my outline:

- Where did we start? Spreadsheets, static web sites, zip disks and sending inventory around from place to place

- Fixing current business problems

- Where is your pain? Start there

- Letting operations lead - Use the adilas interactive map to help show flow

- At some point, accounting will need to follow

- Checkpoints and flowing data

- Gap between operations and accounting - drawing the gap, horses and carts, and old school T accounts - light history of accounting

- How does time play into the mix

- Comparing operations and accounting in a static environment

- Comparing operations and accounting in a dynamic environment

- Progression - drawings of the data assembly line and how it ended up at a 3D data assembly line

- 3D world building - x=time, y=resources, z=space or depth - draw out the box or cube

- Black boxes & white label options

- The whole deal

We didn't quite make it all the way through the whole outline, but we covered a good portion of it. Towards the end, we went around the room and got some feedback. Those documents and notes will also be uploaded. The final request from the class was to have adilas allow the "adilas version" spreadsheet to be shared with the world. It was originally created in order to get a bank loan, but Steve said to release it to the world. Great meeting and good energy on day 1. Good stuff.

--------------------------------------

Day 2

We spent most of the day working on and going over inventory tracking and point of sale (POS) features. See the attached videos. We also had some great demos from Calvin Chipman on building custom labels and one from Dustin Siegel on some new code and features that help with plant phases and cultivation. Here are a couple of notes from some of their presentations. For a more complete version, you may need to watch some of the videos from day 2.

- Calvin and the adilas label wizard - He gave a slide show and then started to interact with the label builder. After he was done, we asked him to show some of the behind the scenes pieces of his label builder. Good stuff.

- Vaporware - the product doesn't fully exist (yet) - part concept, part actual, not yet fully functional

- User designs the label (step 1)

- User selects the label from inside of adilas (step 2)

- The label(s) are created and displayed on the fly, based on stored instructions, mappings, and special code. (step 3)

- Part of the demo was showing sheet labels with a data merge, labels with barcodes and QR codes, static text, dynamic text (user can interact and change things), data mappings, graphics, etc. Pretty cool.

- Small talk about PDF's, Flash, & HTML and CSS - printing options from the web - Our choice is PDF currently

- Interacting with printers, browsers, and other hardware pieces

- PDF - actual size vs shrink to fit size

- Questions about font point size and possible limitations for compliance reasons - We will leave that up to the users, that way we don't have to chase all of the compliance rules and regulations.

- We talked about settings and maybe limits that could be stored and looked up on the fly.

- Possible template options

- Be careful saying a compliant label

- A good disclaimer to keep things legal according to the local and/or state requirements - put the liability back on the companies and/or users.

- Small story of a company and internal programming wars and war stories - Different places that Calvin has worked.

- It may take a hybrid solution of both software and web

- Small demo of the actual builder - Calvin is going to be taking that and putting it more into a wizard-type format. Currently, you have to be pretty techy to use it. Round 1 - prototype.

Dustin gave a presentation on some new cultivation processes and some dynamic mapping. We had some technology issues, the demo was going slow (Internet) but the concepts were awesome. Imagine going from a manual one-by-one process, to a bulk streamlined process. Huge time saver, plus tons more data points, capturing the whole story clear down to minutes, seconds, locations, phases, etc. Pretty cool.

--------------------------------------

Day 3

Busy day today. We got into sub inventory, why we do sub inventory, customer relationships, elements of time, flex grid, ecommerce, custom emails, group mass texting (GMext Pro), and a presentation by Kelly Whyman (super power user from the Denver area). We are going to be posting the videos and the notes from the day. Good sessions. Here are some of the notes that I took while others were presenting. Once again, see the attached media/content files for videos and other digital notes.

These are some notes from Shari O.'s presentation on CRM functionality

- CRM - The real acronym stands for Customer Relationship Management - Shari O.'s acronym for CRM is - Can't Remember Much - pretty funny

- Good data in = good data out - Fill things out completely and make sure you get good data in

- The client log and how to use it

- Leaving personal footprints in the sand - using the log

- Addin gin a user-maintained history... internal communication

- Cover you own rear-end

- Being business appropriate - have good manners when recording details and data points

- Custom emails

Drea did a demo on how to show/hide transfer packages inside of the adilas/Metrc inventory pages. Here are some notes from that:

- Transfers in and out and how to hide things

- Everything in adilas is flexible

- This new functionality is only a week old

- Talking about manual clean-up and automatic clean-up - doing side-by-side comparisons

- Using the data tables and being able to sort and search data - almost on the fly - re-writing the page based on the data.

- Some of the new CSS cards, tabs, and such - really look super cool and it seems more intuitive - it also makes it look more modern.

- We would love to keep adding new data tables and more options

- As we keep going, we may need more clean-up options

Calvin game a PowerPoint presentation on GMext Pro - This is his group mass texting solution. He did a great job and I think that people really liked it. Here a few notes that I wrote down.

- Pretend like you are a client

- Communicating to a large group or large groups (plural)

- Pitching GMext Pro - great demo and presentation

- Some of the stories of huge companies and how changes have happened and how those big companies weren't able to keep up. WordPerfect and Blockbuster were some of them. Major game changers entered the market and could do things better, faster, and cheaper. People gravitated to those new options.

- Technology happens... embrace it and thrive

- Mass texting and single text notifications - similarities and differences

- Phones and phone numbers - with mass texting, you are basically buying phone numbers so that you can send more texts at a time. Each phone number can only send 1 text per second. So you may need 5, 10, 15, 20, 25 phone numbers to get all of your texts sent out.

- Problems with people giving out the wrong phone numbers (bogus numbers or wrong numbers) - that can break your marketing campaigns - too many wrong numbers and you get reported as a spammer.

- Ways of opting in and out

--------------------------------------

Day 4

Final day of training for this go around. We started out day 4 with a group session on tips, tricks, and best practices. We spent quite a bit of time going over settings, permissions, and parent attributes for items. Steve then did a whole session on the three main parts of the balance sheet (assets, liabilities, and equity). The topic was intro to adilas backend office and functions. Steve took the words backend office and tried to flip it to - let's put the owners in the driver seat vs trying to drive from the back of the plane (pretend they are trying to fly the plane from back in the bathroom with the doors closed). Great session.

The afternoon session was talking about BI - Business Intelligence & Big Data. The group talked about databases, data, and how to both get data in and out of the databases. Lots of fun examples. We then has some other Denver power users jump in and do demos on tiered pricing and smart group buttons, and another one on the process of doing a full inventory reconciliation and full inventory count. Great info and good sessions.

The final session was supposed to be on the adilas model - vision, future, and wrap-up. We were all too tired, so we just chatted and went over a bunch of the things that we learned from the training session. We got some great notes and tried to clarify a few items, topics, and concepts. Pretty casual ending. Great people, wonderful ideas, excellent participation, and memories made. A great training session. Here are some of the notes that were taken while others were presenting:

- Molly presented on parent attributes for items - think of tag or ways to categorize things

- On parent attributes - for example: say you have an item but want to show different brand names or characteristics - Say you are selling shoes... You may want Nike, Converse, Adidas, etc. Or running, walking, hiking, trail running, etc. These would be good parent attributes or tags.

- Parent attributes are huge for ecommerce searching and creating tags for different items

- Russell did a great job on so many different features - we would love him to keep building more features

- Easy setup

- Building your own little shortcuts

- Parent attributes are used for labels, sales, ecommerce, searching, filtering, etc.

- Treat parent attributes like a way to build your own database... eight use the flex grid and the custom fields or use parent and sub attributes.

- Both parent and sub attributes are unlimited and they have a proper data type such numeric, dates, text, toggles, and drop-down lists. That really helps when putting data in and also when querying the data to get certain results back.

- As an idea... what if we build out both parent attributes and sub attributes to all 12 main player groups, inside of adilas. You literally could build your own one-to-many database relationships. The main 12 player groups are deposits, invoices, users, vendors, customers, stock/units, expense/receipts, balance sheet items, elements of time, quotes, PO's, and general inventory items. Currently, parent attributes and sub attributes are only available for parts or general inventory items. Think how cool that would be if we pushed it to the next level...

///////////

- Small note from a meeting during one of the breaks... what is the internal adilas funnel to report an error or a bug? Who gets put on that project? We need to figure out our own process and communication funnel.

- Bryan and Molly and others... funding some of the consultant projects - what is the short list and then where are things at. Basically, what do we have to work on and what are the priorities of those pieces?

- Shannon may be part of this funnel that we are trying to build out

//////////

Back to the main training even... The next session was Steve Berkenkotter and Shari Olin - going over financials and adilas backend office functions. Steve pretty much ran with this subject and did an hour long power session on the three main parts of the balance sheet (assets, liabilities, and equity).

- CPA homepage interface

- Inspecting what we expect - you have got to look at what is being delivered as a final product (actual items and/or tasks or services)

- Going back to the beginning - balance sheet homepage

- When you get a new system, we setup a default bank and default location

- Problem with batching... Say trying to remember 30 days back and/or not getting data and information for a long period of time. It kinda leaves you guessing and/or missing some of the details

- Steve - Think of flying a plain... try to be ahead of the plane... where is it going - often pilots try to think 3 tasks ahead of what they are doing

- Views of the balance sheet - a trial balance - working and checking mode

- Assets, liabilities, and equity

- We covered the difference between the income statement (P&L - profit and loss statement) & the balance sheet

- Values and tax laws

- Depreciation and schedules

- Life cycle - length of the life of an object and/or an entity - time and a schedule to lower a value (usage & wear & tear)

- The IRS has setup the tax game... They want you to play and even play up to the lines that have been setup - think of a game - play to the line

- Where you put things in very important

- Small discussion on double entry accounting - history and pros and cons

- Skate to where the puck (hockey) will be

- The formula is the most important part of it

- Passing things like a hot potato... basically moving things along the data assembly line - roll call accounting

- A balance sheet is a snap shot in time

- Talking about the profit margin and where does that come in to play

- Small holes in the ice - things that are either gotcha's or thin ice (not all the way done)

- Some of the guys and gals were saying that we need - big dumb animal pictures - super simple instructions

- Accounts receivables - Think of that as they have your inventory or they have your endeavor (a promise to pay for something) - basically, they owe you money

- You have to know the story - sometimes the numbers tell the story but sometimes the story tells the numbers what they mean

- Liabilities and hidden liabilities - be careful there

- Hidden costs

- Triggers

- Payroll and payroll taxes - this is a huge sink hole

- Sometimes we can't do things due to the technology - as that opens up, we have more options

- Auto processing and calculating needed values in non-peak times that could then be available for other reports

- Fall backs, redundancy, auto-syncs, and re-syncs

- Turtle up, sometimes the servers will shut down and pull in their legs - kinda like a turtle protecting itself

- We need an all encompassing system to help steer the ship - think platform or system

- Owners - who holds the liability

- Steve - analogy of the tail wagging the dog vs the dog wagging the tail - who is in charge & which way do things flow?

- The owner needs someone who is a decision maker and/or gate keeper

- What is the game plan and do you have buy in?

- The POS (point of sales and inventory tracking part) is only a small part of the puzzle. Very small compared to the whole business realm (world).

- Abundant model - you have to imagine a line of people wanting your services and standing in line - next, next, next

- The backend - really, this is the pilot's cockpit and/or the driver's seat

- Absorption (in take) model & attributing sub costs over time

- Dustin - I want "this" (meaning adilas & underlying data) to argue with my boss, not me.

- I need a business tool & now I can run faster & better - thank you

- Equity

- Net Profit - it comes from the P&L - one of the only connections between the income statements (P&L) and the balance sheet.

- Investment - how was this company funded and/or formed?

- Fracture - just having fun - it keeps doing it (fracturing) on its own... maybe let it keep going and play accordingly

- Change "backend office" verbage to the cockpit or balance sheet.

Towards the end of the day on day 4, we had a couple of power users show some demos and such. We had Josh do a presentation on my cart favorites and smart group buttons (tiered pricing). Drea made a suggestion that you make the pricing tiers as dummy proof as possible. They even pushed the ending values clear out to show a visual warning to the person using the buttons. The other major request was for this feature (buttons and tiered pricing) was dealing with allowing these buttons to be time sensitive for sales and promotions.

We also had Drea go through and show an inventory update and how she does a physical count and then an inventory clean-up. She would pull reports, export data, show/hide columns, add columns, print things out, and have her people go work. Then she showed how the system would take those over and short values and push them through an update PO (internal tool for updating inventory counts). Pretty cool. As we go along, we will need more clean-up tools.  Clean-up tools make things look better and help to give users a peace of mind. We also talked about trust issues and how sometimes it is tough to trust and/or trust people. All of that plays into the mix.

My final note about the training sessions is that those who played with us, live and online, really had a good time and we all learned a lot. Good times, great food, and wonderful people. Inspiring sessions. If you want more details, check out the media/content pieces (notes, excel docs, scans, and videos for more info).

Back on the morning meeting. We did a light summary of the training event and talked about what else we could do next time. We are happy with the turnout, energy level, and the topics that we covered in the Denver training event. We are already talking about going to Phoenix, Arizona, in January for the next training session.

Alan, Steve, and I got in to looking into some pagination values and how to quickly show the correct number of records. That took us into some of the Snow Owl data tables and looking around. We also talked a little bit about getting into the graphical homepages and showing totals, reports, graphs, charts, summary data, etc. If you do a search for "graphical home" on the developers notebook, there are a few older entries.

What do people do on the invoice homepage? They want to see counts, totals, and problems (that way they could fix the flagged records). We may want the data just to display the last 7 days vs the last 30 days (current page load). We could still show the totals and counts, but we would only show the actual data that is needed.

Going back to the pagination stuff... We found a small bug in the older pagination vs the newer Snow Owl pagination. Pagination is a term for showing the next page of n (some other number of total pages). The problem seems to be that the system pulls all the data but only displays a certain number of records. The page can only then work with the number of showing records vs the number of records in memory (show vs memory). Anyways, we were looking into some options there. Josh popped in and was saying that most times, people are only looking for the last few entries vs the last 30 days worth of data. We may be showing too much and making the servers work too hard for something that may not even be needed. We need to head to a quick snapshot of the data and totals and then allow them to drill-down and get deeper if needed.

We had Wayne Andersen pop in for a bit. He had some questions about servers, setup, performance, and security. He is working on some of those pieces. We authorized him to look in to setting up some play sites in the AWS (amazon web services) virtual environment. We want to see what that looks like. We also has some light discussions about how awesome it is to have some of the boxes completely separated and setup as a standalone environment so that all of the corporations (worlds) don't catch the same cold (viruses, database problems, traffic problems, etc.). Good talks with both Wayne and Steve on some of the topics.

Towards the end of the session, Steve and Dustin were working on reporting batch numbers out to the state tracking systems. We talked about a way to push and send over hidden details and then how to gather up those pieces and make our own summaries from the data that was submitted. We pushed up the pagination changes from earlier and then did some light testing. Recording notes and wrapping up the morning meeting.

Recording notes and adding files (media/content) and photos to the element of time for the Denver training event. I also jumped on and helped out Bryan with some questions about servers and the new changes we are going to be making for the adilas community funded projects. I then worked with Dustin for a bit and helped Josh get his local environment setup. Those guys are doing great and it is fun to see some new talent in there pushing things forward.

Back to more notes and adding files for the Denver training event.

On the morning meeting with the guys. Steve wanted a report on Wayne's cross-server database sync tool. We reported and talked about some future options and where we want to go. Lots of potential there. After that, Dustin and Josh started talking with Steve about some of the Metrc stuff that they are working on. They are making some great progress. Steve was the leader there. He knows his stuff because he has been in there in the trenches on implementing the Metrc and state compliance stuff.

I was doing emails and light tech support. We have a client who is wanting to charge some special fees based on certain payment types and then not have those new collected fees show up in revenue. That is possible, but kinda tricky due to the mapping of non-revenue based fees and still having the fees show up as an invoice line item. I also was working with the guys on the Bear 100 mile race and getting their runner list for this years race. The Bear 100 mile race uses adilas as their race (leg and aid station) tracking software piece. Lots of different projects.

Eric checked in and we chatted on the phone for a bit. He has a random error coming from one of his custom shopping carts. We will look in to it more later on today. Shawn popped in. Alan popped in and chatted with Steve. It seems like all of the guys are going in a good direction.

On the morning meeting with the guys. Steve, Josh, and Dustin were tracking down some of the new Metrc API stuff (killing plants and disposing of product). Alan came on and gave us a demo of what he is working on for the new invoice homepage. It will have some graphics, charts, and limited data being returned. Mostly some sums, historical data, and say the last 10 to 25 real transactions (for example, the last 10 invoices, the last 10 PO's, the last 10 expense/receipts, etc.). Great demo.

I was working on a runner upload for the Bear 100 mile runners. They will be using adilas this weekend to track their 100 mile race. Alan went back to working on his charts and graphs and Steve, Dustin, and Josh were working on syncing data between different systems.

We ended up having a really good conversation about dates, times, spans, buffers, logic stacking, data threads, and helping to do clean-ups. A lot of the conversation was dealing with how to sync up multiple servers (even potentially servers owned by different companies and/or systems) and how dates and times are pulled. Very interesting how things come back to time and how you sometimes have to either buffer and/or take spans into account. Time feels very solid and static, the problem becomes just like a line in the sand... if the record is on one side or the other, no problem. The problem comes in when it spans and/or plays through a given area (like a line in the sand). That gets tricky and the computer code or query has to be either flexible or somehow incorporate the span and/or buffer. Interesting how it kinda gets into adding in flexibility into a rigid or super tight system.

It reminds me of how we have seen this over and over again, how the system needs to flex and allow for bubbles and/or areas (virtual pods) where things can flex and then it comes back together at a future point and/or checkpoint. Here is an older entry with tons of good info (10/14/2014).

https://data0.adilas.biz/top_secret/time_web_gallery.cfm?corp=371&id=2894

Bryan jumped on and we were looking over some code changes. We merged in some code and then further tweaked some things. One of the new changes was a special header change for a corporation (showing who is logged in on every page). We also merged in a new 3rd party error log for who approves the different discounts. This is somewhat of a hidden history piece, but we are now starting to capture who is the manager approving the different discounts in the system. This new history is tied to a corp-wide setting of whether or not the corporation requires an approval or not for applying discounts. The reason that I said it is hidden is, you have to know about it and get a special permission turned on even to get to the reports. Basically, if we need to capture something that may be sensitive (we don't want everybody to see it), we can do it through the 3rd party error logs. We then get to control who has access to those reports. Each report has a special key pass coded (how the errors are stored and retrieved for reporting processes).

After Bryan jumped off, Dustin jumped on and had a quick question on some of his JavaScript and AJAX calls. He is getting quite good and is bringing in some new functionality. That is exciting.

On the morning meeting with the guys. Dustin was reporting to Steve about some of his progress. He is brining some cool interface pieces to the table. That will be really cool. I was working on a non compete and non disclosure document for Full Circle and Adilas. We are going to be pulling in some of the Full Circle marketing, emailing, and texting services under the adilas roof. That will be awesome.

Calvin popped in and we had a small discussion on new permissions for his adilas label builder application/program. We went through a few questions and scenarios and then created the permissions. They are currently hidden, but will be release as soon as they are ready. We got the new permissions pulled down from data 0 to his local box for testing.

After that, Calvin gave us a label demo to those who were on the morning meeting. I saw a demo (recording) from a couple of days ago and wow, I was impressed with the changes and the direction. It was really fun and we even pushed it pretty hard to see how it would responds. Good report and great progress there.

Towards the end of the session, I was working with Steve on passing in dynamic sub inventory attributes for some of his bulk functions on his plant pages (move in bulk, add in bulk, record plant phases, harvest in bulk). Working with sub inventory and sub attributes within sub inventory gets pretty deep, pretty quick. Lots of moving pieces.

Eric and I jumped on the afternoon meeting. We had some discussions about master special accounts and being able to add/edit master rules. Eric was coding and I was working on some other projects. We talked about things like: Setting start dates for loyalty points, what items to include and/or exclude, how to handle new rules and settings (even in the future, after the initial setup process takes place), etc. We also talked about, do we want to allow for options of adding new rules per special account or just stick to options to edit copied master rules? How does it all play out?

As we were coding, Eric was making some notes and asking questions here and there. Also, there were other developers on the call. Most were pretty quite, just working on their own stuff, but every once in awhile, someone would chime in and/or ask a question. Towards the end, Steve and Dustin had a couple questions about using the session scope and putting things in/out of the session scope.

On the morning meeting. Alan and Dustin were working on complex forms and passing dynamic data between different pages. Lots of AJAX, JavaScript, and JQuery. Alan did some demos and explanations on some new session based permissions checks. He should be launching the new graphical invoice homepage today. It has tons of charts, graphs, and summarized data.

Calvin popped in and went over some of the new API sockets that he will be using for the adilas label builder. He is going to be using about 8 or 9 custom MyEasySoftware API 3rd party sockets (custom built for his label builder). He also went through some other flow and button options to show us some of the progress. It is looking good. He passed me some new table definitions and I wrote a small database update file for him so that all servers and developers could get updated records. As a future note... eventually, we will need to update every page that currently has adilas paperwork (custom document assignments) so that they can look-up and show the custom labels and assignments that get built through the adilas label builder application. Cool stuff.

The guys were in looking at bootstrap CSS pieces, templates, and dashboards. Steve, Dustin, Josh, Alan, and I were all looking. Here are a few of the links that they were looking at:

https://wrapbootstrap.com/

http://wrapbootstrap.com/preview/WB0F82581

http://webapplayers.com/inspinia_admin-v2.8/

After that, we all broke into our own little areas and worked on projects. I was working on some new navigation links for the snow owl theme headers. I got my code done and pushed it up live. More work on checking code for the sales tax project.

Random notes from the day. Brian Stewart is a friend and 30+ year computer guy and programmer. He works for a different company but we go walking and hiking together in the mornings. We talk business and code while we walk. Here are a couple of gems from today.

- There is a difference between working in your business or working on your business - Brian Stewart on a morning hike.

- Create systems... Instead of setting pass/fail goals... create a small system and then start playing the game. Success is playing the game and working the system. The results will usually end up following. - Brian Stewart on a morning hike.

- Brian and I spent quite a bit of time talking about good cop, bad cop, and helping to setup the community and environment that you want for your company. A lot of the discussion was dealing with finding that balance point between speed, function, stability, and beauty. Not everybody has the same personality and/or skill sets. Lots of mixing and blending. Some of the conversation was how to mix senior developers and junior developers and to help them play well together. Sometimes that mixing becomes an issue and also a who gets credit for what and who gets paid for what. Sometimes a tough mix.

On the morning meeting with Steve, Dustin, Alan, and Josh. We started out and got things going. Dustin is going on a trip soon and was reporting about some areas in the North East that he will be visiting. Sounds fun. Here are some other things that happened on the meeting.

- Helping Dustin with some FORM logic. He has a ton of form field data that needs to be dynamic, grouped, and passed over to an action page and still be able to maintain its complex data format and maintain its special groupings. We went through a number of scenarios and he took a number of screen shots. We talked strategy and I showed him some similar code that is used for duplicating PO's and passing dynamic data from page to page.

- Talking with Alan about the idea of on purpose allowing the view of the pages to fracture and be more controllable. We did a small graphic (drawing) and talked about how we have known form field values. We also have a known database table that could hold the data field settings such as show/hide, defaults, data types, special instructions, sort values, field name aliases, etc. We then talked about how we could potentially use ColdFusion custom tags to hold the logic to dynamically populate and/or build the HTML (web format) pages based on the custom tags. The custom tags are a combo between a function and an include. Anyways, we had a good discussion on that. Alan was saying that this plays in perfectly to the MVC (model view controller) type scenario that we would like to use. See attached for a small drawing.

- We had two other outside parties come into the meeting. We had Molly (an adilas consultant) and a guy by the name of Ryan McCorvey (a user for McCorvey's Pro Shop - Bowling). They both had similar requests. They have different pages and reports (or functions) that are hitting time outs. Both companies have tons of data and Alan and I were taking notes and looking for possible bottlenecks and either slow queries and/or slow database tables. They could do the same reports and actions with small amounts of data, the system just choked and/or timed out when trying to process too much data. Kinda like getting a huge mouth full and not being able to chew and/or swallow. Anyways, we worked with both individuals and took some notes. Alan started looking into some research on what causes those table level slow-downs and what not.

- As we get into bigger and bigger datasets, we have to play well with scalability, indexing, and being able to play the big data game. Interesting how things keep progressing.

On the morning meeting with the guys. Dustin started out and showed us some cool photos of his trip back to New Hampshire. Alan and I got into a discussion about MySQL databases and different table engines or table types. Dustin, Josh, and I then had a discussion on how best to code a page that has some complex batching and grouping. We laid it out with three proposals and chatted about each. Both Josh and Dustin are working together on this project. Dustin in coding things and Josh is helping him with ideas and best practices (peer tutoring).

I switched gears and started looking into the black box code on the sales tax project. Towards the end of the session, Steve and I got on a phone call and talked some strategy and where we are headed. We also went over some of our payables and made some plans there. Trying to stay ahead of the game.

On the morning meeting with Steve. As we were going through emails, we had more requests for custom homepages and even some users wanting to go back to the classic invoice homepage vs the newer graphical invoice homepage. We then started talking about all of the different levels of custom...

We went into corp-wide settings, group settings (12 main player groups), page level settings (page control - how does it look and what does it contains and how does it work), and clear down to personal settings.  That got us into a small talk and conversation about an adilas "fracture" account. This is a concept of breaking everything down into mini pieces that could be stringed and/or put together in any combination. This could include pre-sets, pre-built options, special skinning, etc. It could also get into real in-line database extensions, themes, core black box options, etc.

What we are really selling is... We have tons of things pre-built and have a viable solution that has tons of functionality. This is ready and out of the box. We then offer people the chance to build their own application and virtually extend the functionality to what they really want. Basically, Steve was talking on a sales level, and was thinking about having a number of checkboxes... when meeting with a company, you could virtually check the boxes of what we have, we could also allow them to then pick and choose what they want to add on. Basically, we, as adilas, could tweak out our own product and create all kind of custom wire jobs.

We need to apply our own client filters and see who wants to play. We don't want to get over our heads, but we have a great number of guys who can do and handle certain pieces. We have a solution that is usable, right out of the box. We also have a platform that is customizable and moldable (like clay). Steve was also talking about selective selling and really selling our model vs just the system. Not everybody is a fit for what we do and/or offer.

Idea from Steve... Run the system for 6 months and get good at the system. Then come back and tell us what you want to tweak out and/or change.

People want major functionality... however, they also want it to look a certain way (how pretty is it), they also want a level of control (what can they tweak and change).

Function, form, and control - Alan was mentioning the word "Control" - that gets clear down into that fracture type level. We could have preset templates, show/hide settings, toggle on/off settings, permissions and sub permissions, main pieces, sub pieces, and even show/hide of the different modules. Currently, we have everything available... we may actually want to look at module level controls. For example: do you use payroll? do you use stock/units? do you use x or y?

Idea from Alan... What if we did some testing on new users and had them do certain tasks. We then see how intuitive the process are. This would be a refining process and then work from there. As a side note, we have been adding on for years and years. That is our current model. Maybe we need to rework our inter core and make it more module based and then be able to show/hide and/or be able to toggle things (full sections and/or pieces) to an on/off level.

We also talked about packaging and limited packaging of the system... For example: The limited package, the standard package, the deluxe package, and the mother load... package. Not sure what to call things... but it could be really cool. Basically, it all exists, we just show it (smoke and mirrors) in certain ways. Based on the package style and/or level, we could show/hide other pieces and/or features. Another analogy is a race car engine and then we offer the body styles like cars, motorcycles, vans, trucks, semi trucks, or even UFO's (see attached for an older image).

Adilas has a lot to offer... but what if I only need it for this or that? It sometimes feels like taking an army tank out to hunt birds, say something like pheasant hunting or duck hunting. Almost an over kill. What if we could dumb it way down and make it more approachable. Make it into smaller bite size pieces and then let them get deeper if they want. As a side note, like the ice berg analogy, we only show the most basic pieces. Then, if they want more, we allow them to get to it. Maybe either offer certain packages and/or hide everything by default and make them turn it on (at a corp-wide or world level and also at a payee/user level).

Steve - how do people want to buy things? We then need to cater to that level. See the photo gallery for an inverted funnel analogy. Currently, we have people enter with all options (like the top side of the a funnel) and then have them select what they want to get to the smaller level. What if we flipped that model and started out super small and basic... then they could either buy and/or turn of additional modules and/or features as they need them. So, basically, we start super small (like the bottom of the funnel) and work outward (getting bigger like the top of a funnel).

Alan - would like to do a cognitive walk through... What path do they take to do a task? Where did we want them to go and/or do? Where are their eyes on the page and where are they spending the most time? How easy was it for them to follow the path that is wanted? The cognitive walk through would include a small user group, and then the persons being tasked with the tasks would have to explain (verbal and/or written) what and why they are doing what they are doing. Basically, getting into the minds of the users and what they are seeing, focusing on, and/or actually doing.

Wire frames (interactive outlines) and getting to the basic decisions and taking that research back to the coding project. What is the phycology behind the decisions. What are the human levels that we might be missing and/or could really enhance just by display, menus, and structure. In Dustin's words... "putting rails on things".

We also talked about doing different cognitive walk through groups (users not familiar with the system) and how they would do their own different tasks. If they get stuck, why? What were they looking for and what were they expecting? This is more of a cognitive (brain activity) exercise to see what the thought process is and/or could be. One of the challenges for us might be - so many different business verticals and so many different choices... we might need to get a sample and make sure that we aren't hitting just one niche and/or personality type. Lots of different flares and possibilities. We would like to match who would be using the program with what we would be asking them to do. This testing also has some down-sides, such as preconceived notions, using other existing and/or older products, and actually testing people who would be using it.

Alan and I were talking about who we knew and what resources we could tap into to get some basic testing. Just throwing around some ideas. We added in a new community funded project to get in there and do some research and some of the cognitive walk trough's.

After that, Alan and I were reporting on our different projects. We love the options of having black box code, but there are teeth to that as well. We are starting to see the black box section as a huge time sink for the developers if they are making core changes. We have code that is not in master (in the main code repository), it could be changed at any time, and no one knows who has the last cookie. The developers work directly with the clients, and thus, they think that they have the latest code, but a new change could have been cascaded through to the other pages. We definitely need the black box code options and framework, but we need to eliminate as much duplicate code as possible. It is becoming an issue. It is not on fire, but it becoming a thing that needs to be addressed.

Wayne popped in and reported on the database migration project. He is planning on running some new tests tonight. He went backwards and did some major back testing and going back to a test driven design philosophy. He said that he got a great reminder on why we need to stick with a test driven design philosophy (watching out for the little things). The data migration process is super deep... it is basically allowing two different servers to run as they are... then in the background it takes data and tries to re-sync the data to get a perfect match, even though they are different databases with different auto id numbers. That is advanced mixing and blending.

We got into a bigger discussion about standardizing data and using special tables such as flex grid tie-ins and custom dates, numeric, and custom text fields. Some of those tables are great double agents and/or chameleon type tables (they switch as needed). Good stuff and it really seems like Wayne is trying to think beyond the current project.

We are constantly chasing a moving target... part of the fun... :)

Bryan and I worked on a few of his projects. He had some question and we looked over some of his code. We went in and talked about the bulk edit page for PO line items and adding new outline options to help update the sub barcodes. This would be some other enhancements to help out that bulk edit page.

Next we talked about a new project to show/hide options for the secondary vendor/payee options on printable PO's and save as PDF PO's. This deals with some new corp-wide settings and then cascading things around.

As a fun side note, Bryan is now officially a grandpa. His oldest daughter just had their first little baby.

Steve and Bryan were talking about the almost constant need of our clients to make and build custom solutions. Almost like an open source software solution, but we are the entity that helps them tweak things out and get the changes that they need.

After Bryan left, Dustin and I helped Steve out with some JavaScript questions for his new custom pages.

Happy Halloween! As a fun side note, both Steve and Josh have Halloween as their anniversaries. They were able to chat and have fun talking about that.

Calvin popped in and we got some API stuff working on the adilas content server. He needs that functionality for the new adilas label builder app. Good stuff.

Alan, Dustin, Josh, Steve, and I were on the morning meeting. Steve had a couple of questions about some emails that were going around. We pulled in Alan and chatted about some database restructures, re-indexing of records, and full table rebuilds. We then talked briefly about a client that has a bunch of custom code but hasn't really been able to get things going. They are currently not paying their monthly bill and not responding to the David B. and Shari O. We have decided that we need to turn them off as it is costing our company trying to chase their company. If they want it, we can easily re-flip the light switch back on.

Wayne jumped in and we did some checking on his database migration code. We logged into the dedicated server and ran a couple reports. All of the data looks good and he will be contacting the client to let them know. This project has been ongoing for about 2 months now. Basically, we migrated about 10 corporations off of one of the shared servers to their own dedicated servers. Well, once we finished and released the new dedicated box, they came back and said, what about this other corporation that we had no notes and/or record of. Because it missed the normal migration process, and the new server was already live and consuming auto id numbers in the database, we couldn't do our normal migration process. Instead, Wayne had to write a new program that allowed for both servers to keep running at full speed and still be able migrate and copy database records across between servers. That may sound easy, but think of all of the auto id number and foreign keys based off of the auto id numbers that could get messed up. This was a very deep project. It looks great and seems good to go. That is awesome.

We intend to use this same program (actual software we have to run on the physical servers) to help us migrate other clients off of shared environments and into either other shared servers and/or to their own dedicated boxes. That is a huge break through for us. Good stuff.

After that, I jumped in and did some emails and tech support stuff. Towards the end of the meeting, Calvin jumped back in and we made two of his permissions go live for the adilas label builder. We then did some light testing on the live servers. It still needs some lovin, but we had a successful live test between data 0, the content server, and Calvin's adilas label builder app. That is pretty cool. He was going to make a couple changes and then get back with me. Pretty cool and some great progress.

Jumped on the morning meeting with the guys. I got pulled away on a phone call with a potential client. He showed me some of what he is currently doing (all on spreadsheets) and we talked about where things will and/or could go next. Great meeting and we will be doing a small demo with him and his people tomorrow morning. After that, I did some small to do list stuff and buttoned up a few pieces.

The last hour, I spent some time working with Dustin on his custom pages. He has a semi-complex system that allows for items to be checked and then grouped into mini sub groups. We planned some stuff out and then actually went in and started working on the code. It ended up being a bunch of mini loops. We had fun talking about the steps and then actually doing the loops within loops and figuring out the data pieces. Great session.

As a side note, Dustin is gathering tons of info and then needs to auto increment a huge 24 digit number that has a mix between alpha and numeric values. That is part of his loops within loops stuff. We gave him a smaller page that does a similar process and he will be working through the logic and making it part of his page. The values can be pretty complex.

On the morning meeting with the guys. We had both Wayne and Calvin pop in briefly. Most of the morning session, Dustin and I were working on his code to auto increment these huge RFID tag numbers. Basically, you start with a huge 24 digit and/or character tag and then increment just the tail end. It has tons of zeros, alpha/numeric values, and an incremental portion. We spent a lot of time going over the sub loops and loops within loops. We got it and it seems to be working great.

Around 11 am (ish), Steve was showing us some cartoons about a dog. Anyways, Kat, Danny's wife, was telling Danny (one of our sales guys and label developers) that adilas was kinda like a dog. You tell it to go and do something, and it tries to go and do it. Anyways, Danny took this idea and worked with a guy from his church and came up with some fun cartoon dog images. Really fun. The artist's name is Naters Art from the Salida, CO area. Adilas is the word Salida spelled backwards. Kinda fun. Anyways, Naters came up with some great images of this dog, rolling over, with a bone, searching, and tilting it's head. The developers on the morning meeting were saying that they could see some of these images being used as icons while waiting, searching, success messages, error messages, info messages, etc. Lots of good laughs. See attached for a screen shot.

11 am -  meeting with Gene Spaulding with the SAL Management Group. GoToMeeting

We started out the demo and meeting with letting Gene show us around in his spreadsheets and what was connected to what. Really cool and he has taken things to a huge and super deep level. Steve and Gene were able to briefly talk about how both of them started at the spreadsheet level and then eventually grew out of that and into a database type technology like adilas. Good stuff.

One of the main pages that they had was titled - Census and Roster - who is where and what is what (simplified operational and accounting data). This fed the rest of the reports and pages.

Steve - what would be mission critical for you guys? They answered that it was the census and roster reports (getting data into the system). Simple screen to gather that information and then disperse it as needed.

They do have a 3rd party that does all of the onboarding platform stuff. All the paperwork, contract stuff, legal stuff, etc.

They have looked at some of the big huge platform applications out there... they are kinda looking for something smaller and maybe more custom. We did a demo and I think it went pretty well. I had Dave Forbis and Steve on the call with me. They had a controller and head manager on the call. Good back and forth and we had some fun.

On the morning meeting with the guys. Steve had a number of questions about static IP addresses and locking servers down based on IP addresses. He also wanted a report about the demo that was going on yesterday with the assisted living guys. I gave him a report and he made a few comments. Oddly enough, some of the same things that the assisted living guys need and/or want, the campground folks want the same things. Both companies are virtually selling and/or renting one or more of their locations (camping spots, RV spots, or apartments or rooms). Interesting stuff.

This is just for me, but I wonder if we should add a small flag to the locations table to indicate what is rentable or not. We could then pull certain reports and show what is available or not based off of that flag and elements of time. Just a thought.

Alan popped in and reported. He is working on gathering up all of the permission based code and putting in all together in one cfc (component or file). That way we don't have to search all over the place for that same code. Another thing he is doing is limiting the number of page level queries that run to populate the snow owl drop-down menu system (tons and tons of links all based off of permissions). We set up a time to meet later today.

Josh, Dustin, and Steve were going to jump onto a Zoom meeting to go over things. Dustin is working on bulk cultivation pages and custom code. Josh is working on a new and upcoming discounting rules and discounting engine for system-wide discounts. All great projects. We merged in Steve's branch of code and got him all set that way.

I spent most of the session doing tech support emails, a small bug fix for duplicating expense/receipts, and working with Drea (adilas tech support) on a question about updating child inventory quantities. I didn't quite get finished with the bug fix, so, I'll be working on that after lunch.

Mostly a work session today. When the meeting started, we had Steve, Josh, and Dustin on with us. Steve had a few questions and was trying to get some direction. He is making tons of progress on his manufacturing and build pieces. He now has in-line transfer invoices happening when you use his bulk build pages. I worked with Dustin a bit on some dynamic looping (not straight forward looping but associated looping or random looping). After that, I worked on my own projects and everybody else did the same.

Just for fun... Steve, Dustin, and I were talking about the cartoon adilas dog concept. Steve had a colored prototype of the little adilas dog and we were talking about it. See attached for a colored prototype of the little dog adilas. As a question... what will I train my little adilas to do today?

Steve was working on some changes for ecommerce and being able to show tiered pricing out in ecommerce. Alan popped in and had some questions about in-line discounts for my cart favorite buttons. We are trying to see where they need to be attached. We are seeing three possible options. One is on the exact search (known item or known sub item), as a standalone or cart as a whole option, and also as part of the smart group buttons (tiered pricing). Alan is going to check more into this and get with a client who is looking for these options.

Wayne Andersen popped in and help both Alan and Brandon with some server stuff. He is implementing some server monitors that check services, CPU usage, RAM memory usage, database activity, and other monitors. He gave Alan and I a small tour and had us setup some things, in order to play.

On the morning meeting with Steve and Dustin. We started out with some light catch-up on what everybody did over the weekend. Steve had a question on some ecommerce stuff. He is working on getting some tiered pricing out into ecommerce. Bryan Dayton came by my house to get the Dymo label printer. He is working on some custom labels for a client. Wayne popped in and gave us some updates on the servers. Having someone dedicated to watching and helping the servers out will be huge. Alan was on as well, working in the background while the meeting was going on.

Steve was showing us a small demo of some of his tiered pricing out in ecommerce. We had Kelly come on and gave him some feedback. It is literally crazy to hear what they, the users and consumers, really want. It gets super crazy and they want a multi-flipping gymnastic display with super easy functional and beautiful at the same time. The deeper we go, the more things are really flowing and trending towards more configuration settings and then being able to display things in a really simple format. Another thing that I am seeing is the need for specialized and specific interfaces, per business vertical. It is crazy how much people want and how quickly they want it. That makes for a tough mix.

Creating a layered approach seems to work better. The user experience is huge. On that same level, we are seeing a growing need for a developer to code it and a designer to help with flow and the user experience.

As Kelly and Steve got deeper in the ecommerce demo, they, were asking for more searchability, more multi select, more JavaScript show/hide filters and menus, etc. They want the moon and even demand it. Kelly would like to do a different session where they, (Steve, Kelly, and Dustin) go in and do a look around on other ecommerce sites and get ideas of good/bad/ugly and then make a plan from there.

These are some questions that are going on in my head, who is coordinating all of these decisions? How is it all going to work and play out? Who is funding what and who is driving what functions and features? Assuming that we have the funding, who is going to plan, design, and code it? Huge demands and huge questions.

The conversation started rolling over into complaints about look and feel, server up time and/or perceived up time, and other perceptions for the users. They were talking about levels and costs to get to those levels. It then got into a discussion between web, on-sight servers, software, hardware, hybrid solutions, apps, mobile, etc. What are the expectations and what is expected?

Kelly wants us to get pricing on what it would cost for this and that. Steve came back and was talking about how the system keeps growing and developing and who is going to pay for this and/or that. Kelly then was talking about costs and choices that need to be presented to the clients. If you want this and that, you need to pay for this and that. If you only want a smaller set, you would hope that you only need to play for that piece.

Steve was talking about the cost of, even say, your worst employee? It most likely will be $2,000 to $5,000 per month. What is the cost of the adilas system? Say maybe $200 - $400 per month. There is a known disconnect, the adilas system provides tons of functionality, but yet, the price is itsy bitsy tiny and therefore sometimes perceived as less important. The conversation then turned to how do we support the bigger clients and what are their needs.

Wayne popped in and was reporting on servers and server stability. FTP and FTPS - normal and/or secure file transfer protocol issues. He had some questions on how do we keep the servers up to date, synced up, and how do we manage the custom code (things that are different per server or per corporation). Custom code is somewhat of a wildcard piece and/or variable per server. We talked about core adilas code and custom code and how they relate and interact. We also talked about ways to manage custom code and who has what code and/or reports (we need a system of recording who has what and what it does). We have had requests on the client side - am I running custom code? We have also had requests on the tech support side - are they running custom code? We have also had some developers ask the same question - are they running custom code? Kinda interesting - lots of different angles to cover and what not.

I got a call from Bank of America to talk about some term loans and/or revolving business credit lines. I was on the phone for 20 minutes and the rep is going to be sending us some information. They have a couple nice looking products that have way better interest rates as compared with Kabbage and other high interest options.

Steve and I were talking about the future of software of a service is - we do build a product that has as many permissions and features as we can see to solve the needs. The future is that the clients want to customize the results and/or the output. They all want some kind of specialized output. Each client wants to mix and blend the variables in a different way. This could be seeing the data in a certain way (report and/or dashboards) or they have a slightly different process (add/subtract certain steps). Steve is seeing that there is a cost to switch systems, so we are hoping that our clients have basically, choose your platform and then invest in your solution to make it almost your own. Custom solutions that fit people's needs and how they want to play.

Sometimes with bigger clients, you actually get beat-up more and they still may not be happy. We need to find the clients that are happy with us and even bring us donuts... :) We want to find the correct level for us and our company. Bigger is not always better. From Shannon - it is an abundant model. That is awesome.

Picking your battles and multi-concept decision making. That is quite the game. Fun, but very challenging. Question - who wants to play? Great, let's play. Lots of indicators, you just have to make decisions according to those indicators. Adilas is a giant idea farm. We will keep building and breaking things. That is somewhat of our model. We want to help businesses succeed. Those who want to play with that model, we love it, let's play. On the financial side, we are so glad that we don't owe anybody huge amounts of money. That is freeing to the mind and the soul. Good stuff.

This is on a different note, we would really like to circle back around and see where we are at on the accounting side. Most of our current efforts are still focused on operations and operational flow and process. There is some huge potential for future growth in that area. We need to keep working on and refining our plan. The other area that could really use some loving is the user interface and the look and feel. There is a constant progression from one thing to the other. That is fun and exciting to see and even revisit those pieces.

Steve jumped back into a recap of where he started with the coding and development side - simple HTML and web stuff on the old steps to success. As you get deeper and deeper, you keep needing to step outside and get deeper in the complexity and background pieces. Lots of moving pieces under the hood, but it looks super simple on the outside.

 Steve and I are realizing that we can't do this whole project by ourselves. We have a great little team and we are even refining things within that model. That is exciting. It is the team that wins the battle, not an individual. We are learning tons and tons about the software as a service (SaaS) model. Our plan it to keep going at the current pace, keep building, and keep listening. Our plan is to run as fast as we are able within the bounds of not running faster than we are able.

We are happy to keep building up the core pieces. We are seeing numerous outside parties that are catching the vision and building out more and more custom stuff.

Dustin jumped on the GoToMeeting session and had some questions about his custom bulk cultivation page. We are working on the action page (making things stick and/or be recorded in the database). His code allows for small pieces to be selected and then either transferred and/or flipped between a phase of the cultivation cycle. His code gets pretty deep as it allows multiple things to be flipped at once. We spent the whole session going through a small build out process of taking what we have (passed through the form scope) and creating a complex data structure or object to represent what was submitted. Tons of arrays and structures within the arrays. We had to write things out in plain English before building it... it was quite deep. We finished up and left him in a good spot with some minor tweaks to make for that part of the page logic work. He still has more to go, but I feel good about that part of the logic map.

On the morning meeting with Steve. We merged in some of his code and then made a few new changes. Alan popped in and gave us a small report. Dustin was also on the meeting and working on his own stuff.

Eric popped in towards the end of the main morning meeting. He and Steve were talking about category level rules on expiration dates and how to track and process items as they age over time. Basically, keeping track of expiration dates and helping to flag and move inventory to help keep things fresh and moving.

There was also some discussion about part/item categories and parent attributes. Both tools are well used and there is some cross over between them. The difference is how many things may be applied per item. Only a single item category may be assigned per item, but an unlimited number of parent attributes may be applied. Sometimes, the clients and users, and doing some mixing and blending. We may need to keep looking at that and maybe even allow for some rules, flow processes, etc. What we are hearing is the need for high level rules and then applying those rules to the items that are cascaded under that category. Basically, grouping and sub grouping, even inside the categories. Steve and Eric would like some other filter options for the main categories. Almost a mix and blend of categories and attributes.

There is still a growing need for sub categories within the main part/item categories. It is amazing how many new feature requests keep coming in on a daily basis. Pretty crazy.

This is just a side note... but we are getting more and more requests for some of the subs of elements of time to be applied to other pieces of the system (other 12 main player groups). We would love to push that out and allow for it to happen, but it just hasn't been built out yet. These are things like: color codes, sub dates/times, sub flags and tags, sub locations, sub phases, sub grouping, sub notes and comments, and sub sign-off's, and such. We have tons of ideas on this (virtual adoption process between elements of time, subs of time, and other system players). I'm excited to see where these things go. As a side note, we could create daily elements of time for certain things and/or tasks (this almost creates its own group) and then you move things or flip things from there.

We are also seeing a problem with some companies that use adilas for just one or two processes, but they don't use adilas for the whole thing. That creates problems because things can't flow from phase to phase and state to state. They are kinda wanting things to flow to a certain level and then just magically appear over in some other section. That gets tough to automate that because it is basically skipping steps.

Steve was showing Eric how to setup custom page settings and storing those values in JSON. As another side note, our original goal for the custom page settings was to give every page an id number (web_page_id from the web_pages table). We also wanted to give every CFC method or virtual API socket connection a similar web_page_id number. That way we could track what is being used and how often (behind the scenes stats). We started that process, but got pulled off due to other projects that needed attention. This is a huge piece of the puzzle and would really help if we go to the full adilas fracture account level. Dealing with page level id's, we also need to figure out what is needed for black box takeovers and extended settings of settings and/or conditional settings. It gets pretty deep fairly quickly.

Steve was just dreaming, but he would love to see the adilas application as an artist pallet where you could pick and choose your widgets and where to place them. Basically a build your own dashboard and build your own layout. Steve would also love to see a configurable shopping cart, where users could pick and choose what they wanted to see. Just some dreams.

Another huge observation today... Steve was showing Eric (who has done tons of development for us) around the system. This was huge for Eric and he could see and catch the vision. Sometimes you don't even know what you do not know. One of the down sides to adilas is the current size of the application. It is huge and has tons to offer, because of that, some people never venture into certain areas, even though they could really use the functionality offered. Maintenance and training are huge concepts that need to be pushed and available to our users.

Steve - Question - Is that even a tree you want to cut down? Steve was cutting trees as a winter job, just out of High School, and was talking to a old sawyer (tree cutter) and the older guy was telling Steve to leave a certain tree alone because it wasn't worth it. Steve was young and wanted to conquer and do a good job. The tree had some old barbed wire embedded in the bottom of the trunk. The old sawyer was telling him to leave it alone because it would be a ton of work and may end up ruining your chainsaw. Business is like that, you may not want to cut down every tree in the forest. Abundant model - next! Great advice.

Steve reported about his meeting with Spencer yesterday (flight out to Grand Junction, CO). It sounds like Spencer is quite sharp and also really likes to work with CSS, user interfaces, and graphical look and feel stuff (UX or GUI stuff). That would be really cool. We could really use a good designer and maybe even a person to help train us on what to do as well. I would be super stoked on that.

Steve had a question on how to filter some data out in ecommerce land. His current project is a work around for showing tiered pricing out in ecommerce. We started out looking where he was at on the normal big huge pages (ecommerce searches and search results pages). That was pretty deep, so we did a full test page and coded a small sample file to get us the info that we needed (concept and database level). It was a good exercise and we literally went clear back to the beginning and brought up the small test page from virtually nothing. That exercise helped both of us realize more about parent attributes and where and how things are stored in the database. That project was originally done by Russell and Alan, so we knew about it, but didn't really have deep hand-on knowledge. Good stuff.

After Steve and I finished, I worked with Dustin on doing some sub filtering on his custom cultivation pages. Basically, we ran a pre-query to get certain matching records and then then used those records to filter the next major (actual) query. We then worked on some dynamic AJAX calls. It was working if we called his helper files in smaller chunks, but it would break if we passed too many requests to the helper and builder page. We did what we could and eventually I recommended that Dustin get ahold of Alan to work out the deeper details.

Steve and I were talking about some fun sales ideas and using the new adilas doggie graphics. See element of time # 4216 in the shop for some fun images. We got a bunch of new graphics yesterday from the artist.

Dustin was showing Steve and I some of the new functionality on the cultivation side. It is a nice interface with tons of backend wiring to make it really fly. Pretty cool. Eric popped in and had a couple of questions for Steve and I dealing with mag stripe readers and integrating with loyalty cards and what not. Steve answered most of the questions. After that, Wayne and I looked over a data import on the data 6 server. We talked about some additional pieces that will help the import look and be more clean.

Emails, tech support stuff, and looking into bug reports. Towards the end, Steve and I had a small chat about the assisted living business vertical and providing some guys a quote to use our system. No firm values, but we were playing with options based off of rooms or options based off of facility sizes and what not. Good stuff and Steve is excited to see where things go.

Merging in code with Dustin and Steve.

Meeting with Hamilton from Full Circle at 10 am. They are looking for a January 1, launch date. Josh gave us a small update on where he is at. Customer dash board to show coupons, loyalty points, preferences, and maybe even a self check-in (add to queue). A possible manager's dashboard and tracking throughput and what campaigns are used and ratios for closing those campaigns and coupons. Josh is looking to build out some matrix to help show profit, costs, and other demographics (age, distance from store, etc.).

They are looking to add a flag at the corporation level as well as at the customer level on who is playing with Full Circle (who opted in). If both corp and customer levels match up, we can add additional functionality. As part of an advertising campaign, we may just grey out the fields and help prompt the users to sign-up to get the additional functionality.

Josh was talking about a virtual batting average per campaign - how many messages were sent out, what was the ROI and usage, etc. This will be more than just a response matrix, it will include prices, costs, profits, usage, etc. A mix of different stats and variables. Josh is also trying to tie-in things with his new discount rules and discount engine. This is a combo of both existing discounts in the system as well as mixing with outbound campaigns.

There have been some talks on making a standalone version to capture more market share. Basically, a special functional section for adilas users and another one that is just a standalone, that way it may be used in multiple arenas.

Timelines and vision - Josh is going to be breaking things into chunks to help with development and deployment. One of the keys that has been tied in, this past week, was the line item level of or for campaign tracking. That will be a huge key for reports going forward.

Question by Hamilton - what options do I have if I wanted to stand up my own box (server and databases)? He was talking about a go to market strategy. What are the entry points? Options (1, 2, 3, or 4)? Two scenarios, existing adilas users (what do they get) and new users, that don't use adilas (but maybe hit at what they could have)? Basically, Hamilton doesn't necessarily want two code bases but we may have to try to direct them to the main adilas system. Make it a double sale. Hamilton was talking about a mini version of the adilas platform (small and cute and limited) and then over time, allowing his outside users to eventually migrate over to adilas over time.

We talked about a mountain (show everything) vs a ice berg (limited view but more available)... Josh and Hamilton would like to flip the model and expose a smaller portion that looks awesome but has huge potential as they get deeper. It kinda comes down to the entry point (perception). This conversion is basically talking a mini version of the white label concept with a limited entry point. One of the key pieces is the domain name (it has to be pointed to a single server). We also talked about some dual entry points where we have both adilas domains and full circle domains pointed to the same box. Think of it like doors on a building... did they come in from the front, back, side, or up from the floor below? Piece of cake. It comes back to entry points, preferences, and traffic flow.

Hamilton was talking about "dangling" options in front of his clients... virtual up sales of what else if available. If you purchase adilas as a package, it may be harder to up sale the client - they kind of expect the full package. However, if they come in from the Full Circle side, they Full Circle, could sell and/or expose other pieces based on a more modular pick and choose type model. That could be really cool. Once again, showing the full mountain vs just an ice berg with more potential under the surface.

There were some light conversations between Steve and Hamilton about data storage and processing - who is hosting what pieces and where does the traffic come from? In a lot of ways, we don't really care where the clients come in the door as long as they come to play. We also talked briefly about Full Circle being able to expose small pieces as they become available (breaking the adilas mountain into modular pieces that are add-on's and virtual up sales).

As a side conversation, there was some talks about beefing up the reoccurring billing section (reoccurring invoices) and making it more modular and automated. Billing for our services is a big things for us internally. The easier the process becomes, the less time we have to spend chasing it. That leave more time for other tasks. The tuff part is the technical side, the fun part is the selling of the features - from Hamilton. Hamilton wants to use his existing adilas account and setup reoccurring billing from inside the system for his existing Full Circle invoices. We will have Josh and Shari O. help get Hamilton all setup with the reoccurring billing inside of adilas. Josh was stating some ideas about helping to automate things back and forth between the main adilas accounts and the Full Circle billing parts and pieces.

Quick meeting with Steve to go over some code changes. I spent some time recording notes and touching base with Alan on some projects and concepts. Tons of emails and light tech support stuff. Worked with Wayne, Dustin, and Eric on different projects.

Alan, Dustin, and I jumped on and watched a demo by Spencer for about an hour. We asked him questions and looked at some of his projects and style. Fun stuff. He showed us a couple of responsive designs that he has done and we talked quite a bit about future vision and where we could go internally, inside of adilas. He uses a lot of his own CSS, JQuery, and AJAX to make some fun designs and great one-pager type layouts with loaders, JQuery, and AJAX calls (get the data on the fly without a page refresh). Great meeting.

On the morning meeting with Steve and Dustin. We started out trying to track down a bug on the data 10 server. We finally figured out that a couple of the database tables were missing a couple of columns. We tracked down the problem and got it fixed. Josh and Hamilton from Full Circle popped in and gave us a small update on their progress. Bryan Dayton joined us and had a few questions about sub inventory and getting correct pricing for an API socket connection. We talked about how prices are determined based on possible options (order of operations). First, does it have any tiered pricing (quantity discounts), then to the sub, then to the parent item. Lots of deferring from one possible place to another.

That conversation and session (subs and getting correct pricing) turned into a small talk about the need for mini conversions and pushing the ball forward in that realm. Crazy how things keep going deeper and deeper and what not. Later on, we ended up talking more about the tiered pricing and how it gets kinda crazy with per item prices and total prices (back into a known total for a certain threshold). Things get pretty deep, pretty quickly.

Emails and tech support stuff.

Great morning meeting today. Steve and I started out the conversation talking about progression and who is doing what. We used to be stuck in a model where both of us were running with all of the pieces. We now have a great team and each person has their own expertise and passions. That is awesome. We spent some time going over some new things, and even some potential things that coming down the pipeline. Exciting.

Dustin joined and we did some code merging for him. We had Eric pop in and ask some questions. Wayne popped in and Eric and Wayne did some testing on one of the servers together. Eric was browsing pages and clicking buttons and Wayne was watching CPU's, memory, and databases on the actual server. Pretty fun to see how things are starting to work together.

Alan joined us and we chatted with him. We went over some of the code and new changes between the live inventory update section and the delayed inventory update section (new feature). We went through a number of scenarios and talked about some other needs in that area. Alan also asked about some plans and how we are going to be heading more towards version controlled deployment, testing servers, and that process. Good stuff.

I merged in some database updates and ran those updates on all serves. Good morning meeting and lots of progress in many areas.

On the morning meeting. Steve, Wayne, Dustin, Eric, Alan, and I were in today. Wayne and Eric were talking query caching techniques and switching between aggregate sums and totals and non aggregated (simple transactional data). The conversation kinda went along the levels of watchers, feeders, hooks, triggers, etc. Eric was saying are we going to be building new aggregates based on the old design or are we going forward with a new design and then build aggregates off of the new design. Pretty deep data model changes. What are the impacts to those changes?

One of the questions came up about testing impacts and how does that work. Are we fixing legacy and/or being pro active and moving forward. One of the questions was the po/invoice line items table. It currently has both PO lines (inbound inventory) and invoice lines (outbound inventory) in the same table. The reason goes clear back to location specific levels of inventory tracking. If no locations were ever needed, we would hold thing (line items) in the different tables. However, if you add an unknown number of locations, that complicates the data model and it get hard to be able to roll the inventory levels both backwards (going back in history) and/or seeing current levels.

Going on to a different topic, Wayne and Eric were talking about a testing server and even stress testing certain queries and/or database tables. They were talking about caching queries and how often do we reboot these servers. Because we use Adobe ColdFusion, we've had to implement a nightly reboot to help flush memory. As Wayne gets into the servers and monitoring things, we are seeing that the servers are working pretty hard by the end of the day and then fully refreshing things based off of reboots. That is both good and bad. We are on purpose flushing the cache and the memory. However, sometimes a cache and/or an item held in memory saves tons of time. We still need to compare the info and see what the differences and advantages are. Like Alan said - we break stuff and then we fix it.

10 am - group discussion to talk about servers and new configuration stuff.

- Currently all of our servers are and/or have been setup differently. That becomes a nightmare to manage.

- The server setup is done every couple of months... that makes it hard to remember what the setup process is and/or was. Our goal is to help make our environment become more stable and also more standardized.

- Wayne likes to use a program called Puppet. This allows for a master template and/or recipe to be deployed out to other serves. Similar to ghosting or cloning things. As we install and setup new serves, Wayne could then help and manage those serves. He was talking about server roles, scripts, and applying updates and changes. Setting things up and then maintaining that same type setup over time.

- If Wayne starts taking care of the servers, it enables us to spend more time developing.

- How do we deploy code to the servers? We are currently using Git (source control and version control). We are using phase one where we push code to the server. We would like to use a step 2 process where Git (our version control) actually pushes the code up to the server. When we get to the automatic level of deploying code to all servers, we need to make sure that we have all dependencies in place. This includes our database updates. Currently, the database updates are scripted and then run by users per server. Wayne is talking about a documented process that writes a chain of processes that have been run and still need to be ran.

- We just added a new server - data 11. We are going to be experimenting on that new server and using Git (source control) to push files up to that box. We are also going to be mirroring a new server configuration to help do some side-by-side testing. We are also planning on migrating corporations from data 1 (older server) to the new data 11 server. This is strategic based on trying to migrate clients off of an older server into a newer server environment.

- There is another part of this process - that is testing and running tests to make sure that things are working. Eventually, this could get into stress testing and really seeing where the code breaks and/or cracks (pressure and stress testing). Eventually (bad word), we would like the tests to help keep us upright and to verify that we are still good to go.

- Small discussion about custom code and getting to a confidence level of what is being done and managing expectations with that custom code. There is some more feedback and communication that is needed here.

- We really want this to be a group and a team effort. We are going to need help with ideas, code, migrating, testing, and deploying.

- One known dependency piece is the database update stuff. We have to make sure that the database get tweaked (the landing zone) before we push the code up. We are seeing some sort of cross process where we use Git commits and known processes (order of operations) and then match them up with a record on the actual servers. This would allow us to see code on Git/Bitbucket and also compare that with a list on the actual data servers.

- Small discussion between Windows and Linux boxes. The discussion was talking about database connection strings and where the actually database live (same server and/or remote connections) and where the server-side software exists. How do they connect. We also briefly talked about security of allowing connections between servers, clients, and databases. We are planning on testing things quite highly before anything goes live.

- At what point do you change? It comes down to the burning platform type analogy.

- Small discussion on changes to the database and the code... if brand new and no one is using it, easy pea-sy. Once it starts getting used (people are going and moving at full speed) it gets way more tuff and difficult. We are looking for a moving model and getting consistency.

- Primary goal - keep our customers happy. Secondary goal - all make some money and be able to keep going with what we are doing? Basically, we need a stable process that our customers like and have confidence in what we do and how we do it. That is awesome.

- Wayne jumped in and showed us some of the things that he is watching and monitoring. These are things like: how much memory is being used, how many connections, how many queries per timeframe, CPU usage, hard drive size, and other setting monitors. Wayne was showing us some things from his Nagios server and from his Cacti server stuff. Both are graphing and monitoring systems and what are the trends, traffic, and other server statistics.

- As a side note, we are also going to be upgrading to Adobe ColdFusion 2018 and MySQL 8. Some of the older servers are using Adobe ColdFusion 11 and MySQL 5.6 or 5.7. That should help out as well.

- We will be making changes as the need arises. We don't want to just make changes just to make changes.

- Small questions and answers between the developers and Wayne. Lots of talk about tuning, specializing, and customizing systems, hardware, software, etc. Miss configured settings and getting all of the serves tuned to the right settings. Rollover, fail over, and master/slave type topics. Database partitioning vs corp-specific tables. How do database partitions and indexing effect things? Creating independency between serves and code and serves and databases. Isolation vs shared vs other options. Live data vs old dead data (companies that are no longer using our system). Archiving data, rolling up data and totals, storage, etc. virtual machines vs actual dedicated boxes. Physical locations vs virtual locations of the servers, redundancy, backups, data centers, and even what vendors (hosts) we use. Lots of good discussions.

- Wayne and Alan were talking tons and tons about testing and testing strategies. They were also talking about getting things to the level of being able to apply stress based tests and performance tests. Basically, putting things through the paces. They were also talking about concurrent hits (multiple users doing the same thing) and managing tests based on simulated usage and what not. Good stuff.

- Picking up the low hanging fruit due to no current performance testing and/or performance configurations. As we get into this, we should be able to pick up a few of the low hanging pieces of fruit. That is exciting.

- Starting with the results in mind and then working backwards from that vs writing things and hoping for a certain result. Perception, expectations, vision, and outlook. Some great ideas. Test driven design ideas.

- At the end of meeting, Dustin was willing to help with the testing. That may be a perfect fit. Currently, he has some pretty integrated processes that he is working on and nobody is pulling on him for super tight deadlines (client requests). He is working on internal projects.

On with Steve and Dustin. We got caught up from happenings over the weekend and both Steve and Dustin had a couple of questions. After that, we then all of us went on mute and started working on our own projects. My first task was buckets full of emails and what not. Setup some sub account stuff for Wayne on the Newtek site to help manage some of our servers, support tickets, and account details.

Eric popped in and we setup some blocks of time to work on the sub special account tracking stuff - first couple weeks in January. This is for things like rewards/loyalty points, gift cards, in-store credit, etc. It will be good to get some dedicated time to work on that project.

Steve, Dustin, and I were on the meeting. We briefly talked about who is doing what, and who is checking in and on what projects. Light game plan stuff. Wayne popped in part way through and had some questions. I helped him out for a little bit and then Steve did some training on what we normally do inside of adilas and how to monitor the corporation stats and usage from inside of adilas. Wayne is looking to simulate some of the bigger corporations and build some stress tests for the different servers. He is trying to get things performance tuned where possible.

After that, we broke into our individual projects. I was working on a new printable invoice that has no special formatting and colors and also prints nicely on a single 8.5 x 11 inch sheet of paper. I'll calling it the black and white (plain jane) printable invoice.

Steve and Dustin were on the morning meeting. Steve had a quick question about a custom report for owners. We talked about some security hashes that could help the report be more secure. The admin report needs to be outside the secured environment and kinda a quick access link to a quick breakdown report for admin users. Steve has the report built, he is just adding some security and then going to add an access point from inside the secured environment.

I got a call from Russell. We talked for quite a bit about some custom client needs and how best to proceed with those requests. We also spent some time talking about using Bridgerland or BTech to help build out some of the fracture type pieces. The term "Fracture" comes from an idea that Steve had back in June of 2017. Everything in adilas seems to be fracturing and breaking into smaller and smaller pieces. Just discussions at this point, but basically a centralized brain (backend engine) and then a deployable front end that could be hosted on any client server or through a commercial web host. No special setup and a fully customizable frontend interface. The whole thing would talk and/or communicate through API socket connections and back and forth API traffic. We talked about ideas, options, etc.

If I were to put together a small fracture tick list, it would be something like this: (just ideas)

- Customizable look and feel (corp-level, department level, user level, and whatever in between)

- Preset defaults with ability to tweak out the defaults and settings (good starting spot and/or basic structure - starting templates)

- Permissioned out and/or micro permissioned (down to the functions per section)

- Settings for layout, settings for display (show/hide, sort order, aliases, instructions, required yes/no, validation rules, etc.) - As of right now, we are seeing settings on 4 different levels. They are world (corporation or business entity), groups or system player level (customers, invoices, deposits, expense/receipts, PO's, parts/items, vendors, users, stock/units, balance sheet items, quotes, elements of time, etc.), page level settings (what will show/hide, sort order, placement, flow, etc.), and finally, user level settings and defaults. How do I want to play the game (at a personal level)?

- Existing structure and flow, but it could be modified. Basically, a template of the starting procedure and/or process but make it able to be modular (build mini data assembly line type options per procedure/task). Think of our model with the mini bubbles and/or pods. These interface with flow, permissions, time, flex, and mapping clear out to the accounting levels.

- Real in-line database extensions. This allows us to provide a basic starting point (database tables and template flow) but also allows for things to be expanded and/or contracted (lessened) based off of configuration. These database extensions could be data types and allow for numeric, decimals, text, dates, on/off toggles, and even long text or JSON storage.

- Be able to save and build any kinda of report or data export - using existing tools

- graphics, charts, graphs, and other summary type options

- Support of both transactional data (what happens day to day) as well as aggregated (summed or pre-calculated values)

- Digital story telling, using characters, relationships, cause/effect choices, consequences, etc. World building concepts.

- Configurable interfaces and functionality per business vertical - click of button to switch layouts and/or processes.

- Customizable (data or logic hooks or black box technology) on client side, server side, and display and logic sides.

- Responsive and/or mobile ready

- Tons of flags, tags, and special callouts

- Be able to tie everything to time or elements of time. This could allow for groups, categories, types, sub locations, sub phases, sub status, etc.

- The list goes on... Most of the ideas have been recorded somewhere in the adilas developer's notebook pages. A great resource, it just may take some time to review and categorize. 

----------------------------------------

Back to other topics, Eric popped in and we made a few more notes and decisions on the sub special account tracking stuff (gift cards, loyalty points, in-store credit, etc.). After that, Wayne jumped on and we talked a little bit about email servers and what is needed there. I spent the rest of the time recording notes and reviewing to do lists. Busy times.

Steve, Dustin, Wayne, Eric, and I were on the morning meeting. I gave a small update on my "on site visit" yesterday with the tool company. Tons of new notes and pages of ideas and requests. Wayne wanted to talk about ways of standardizing code, and how things get implemented. He pitched a couple of fun and good ideas. He had us look at an article about ways to use Git (version control software) and have a number of different stages and/or branches. He was also explaining about how he could implement things like this inside of adilas. Super talented and we've never even been able to consider some of these concepts. Very interesting. Here is a link to the article... not exactly this process but some similarities.

https://nvie.com/posts/a-successful-git-branching-model/ 

After Wayne was finished, Eric and I chatted about the sub special accounts homepage and what that would be and/or look like. We made a small plan and then Eric jumped off. Steve and I then started talking about how some of the developers are really wanting to jump in and play the game. We talked about Russell and what he wants to do, Wayne and what he wants to do, Alan and his goals, where Calvin is at, Dustin, Spencer, etc.

Right about that time, Eric popped back on the meeting and was asking Steve about some ideas and concepts of revenue sharing and how we could build things out to a more and more stable working and development environment. Eric was talking about how much better adilas as a whole would be if he was able to build out core features and projects vs doing the custom one-off implementations all the time. Some of these developers work and work and work and then their projects are done. Most of them want something that is reoccurring and/or can be reused over and over again. That seems to be a trend. Very interesting, almost the exact or similar topic that we were on. While Eric and Steve were talking, I was listening and making some mental notes. We don't know which way to jump yet, and we don't want to overload the boat so that it tips (get too far extended by debt and/or payables), but there are some awesome opportunities right in front of us. We have a great talent pool that we know, like, and have the skills to do what is needed. We just need to figure out how to keep funding the journey. That is awesome.

From Steve - he thinks that we have crossed a new checkpoint. We are having guys with talent that are virtually knocking on our door saying - I want in.

Russell's word - "Dependable" on what we called the people on our team.

Steve was also talking about some supplemental experiments with salespersons and people helping to push our product out there. We are going to start funding some small sales missions and covering certain individuals for 10-20 hours a month doing sales. If they get a sale, they are able to charge their normal setup and/or consultant rates. If they are prospecting, they will be on a small adilas budget to help them cover prospecting time and maybe some gas money. Basically, a small "low to no" budget sales force, but helping to augment and/or supplement the sales efforts. Fun stuff.

Towards the end of the session, I took some time and recorded some notes. To some, it may seem like a waste of time. To me, it is what I do and that's part of the job and/or what I like to do. I gain from it in big ways. Whatever I write, I have to think about it, record it, re-read it, and it improves my memory going through that exercise. Anyways, that's why I write so much. Once it is down on paper (virtual and/or physical) I can refer back to it and it lessens the stress load. There is an old saying, the faintest scratch on paper is better than the sharpest mind.

Alan, Steve, Dustin and I were on the morning meeting. The first little bit was each person reporting on what they were working on and what issues are still outstanding. Steve had a couple of questions for Alan and Dustin. They are following up on different tasks. I spoke with Alan a little bit about our plans for some changes in how the sub inventory and sub barcodes were going to be searched and filtered.

Next, I gave Steve a small update on my meeting with Spencer and Wayne from last week. He asked for some drawings on what was going on. I explained that Spencer was at a turning point where he was going to be needing access to actual data. He doesn't know Adobe ColdFusion very well yet, but he is a PHP master. PHP is another open source server side scripting language. Wayne and I decided that we would let Spencer build out his new prototype in PHP and use the adilas API sockets to get and pass data back and forth. That sort of spun us off into a small discussion on where are we going and how are we planning on integrating all of these pieces. That, of course, is a whole other topic. We touched on the need to build out the adilas API sockets (play at the wall - allow outside data connections) and how that would fit.

Calvin jumped on and a couple of the other guys bailed out. Steve and I had a good talk with Calvin. Our current project with Calvin is an outside label builder for custom and bulk labels. Part of our conversation was helping both adilas and Calvin get our communications being built up and on better levels. We chatted, got on the same page, and will hopefully be back on task next week. Calvin still has some other projects that he is working on right now. Good meeting.

Steve and I then spent some time talking about how the trend is kind of going toward 3rd party solutions and 3rd party build outs and then trying to inter connect them with internal adilas flow and processes. This took us back to a subject of PHP and other adilas API socket connections.

Eric popped in and had a couple of questions. He is building an project for sub special account tracking stuff like loyalty points, gift cards, etc. Some of our discussions today were dealing with page flow and naming conventions. We talked about having a new sub homepage for the special account tracking stuff. We then talked about how the user would have to let us know what special account type they were looking for information on, and then what that process would be like as they walked from step to step, adding filtering, and then finally results with drill-downs. Lots of concept level talks about flow and data. Good stuff and I think that Eric is making some good progress. We'll still need to tweak and refine things, but progress is being made.

Lots of emails and other things, just trying to get caught up and going. After that, Steve and I jumped back on the discussion about PHP, adilas API sockets, playing at the wall, internal vs public files, what servers would look like (just Adobe ColdFusion boxes, just PHP boxes, or dual setup of both ColdFusion and PHP per box). We have some questions that we will be asking Wayne about options and direction. We also made some good break trough's by noting which files and servers were private (owned and controlled by adilas) and which files and servers were public (owned by 3rd party and/or outside entities). Just adding what was public and what was private, really helped the conversation and get both Steve and I on the same page.

What we are seeing is that we need to keep pushing for a full separation between the data (database, storage, and access to the data), the logic (functions, methods, API sockets, and flow), and the actual display (what things look like, where they focus, and what they do or don't do - visual interfaces). Those three things data, logic, and display are huge. The more we separate them, the more modular our application becomes.

We didn't spend a ton of time on this... but all of our discussions were somewhat pointing to the greater and greater need for the adilas market (adilas world) to play a part in the puzzle. Currently, we have a saying "Play at the wall" for the adilas API sockets that we expose to the outside public. That wall is basically the access point between the adilas database and logic and the outside world. We are almost seeing a 2nd wall (virtually speaking) starting to form up. That second wall or outer wall is the adilas marketplace and who has what, who offers what, how is it obtained, or who has made pieces that  virtually are able to be plugged in and/or integrate with adilas core functions and functionality? I'm betting that the open market will end up playing a bigger and bigger role as things progress. Our challenge is how to manage that as it grows. Good stuff.

Getting things your way - the power of a custom solution. Steve and I were talking about core vs custom development. Where we are at right now is letting clients step up and have us build certain features. There is no possible way that we could shoulder all of the requests. We just can't give away anything for free right now. The companies that want to play and pay, they will succeed. Custom software as a service (SaaS) allows our clients to build out their own dreams and processes.

We were talking about finishing up some of the existing projects. Sometimes we like to dream and keep building and building. Maybe we need to circle back around and finish some of the outstanding projects. Steve was talking about - is this mission critical or can it maybe wait or hang out a bit? We are trying to get a better handle on this.

Yesterday, Steve and I were talking about mixed server technologies. Steve was also saying, as a reminder, that as we keep building, if we have outside services or 3rd party products, they will constantly need updating and keeping up with the new changes that keep coming. Even though some of the new pieces may look cool and be all gui (graphical user interface) and such, you still need them to be updated with the functionality that keeps rolling out the door. 

--------

Dustin was working on some cultivation stuff and had an issue with a pound sign (#) not passing through his page flow. We jumped on and did a little work around code to help him out. I spent some time and reworked the sub inventory searches for parent items as well as sub barcodes and sub RFID tags. I made a couple other simple changes and tested and pushed up some new code. Eric popped in and had a couple of questions as well. Pretty quite morning.

At the end of the session, I pumped out some quick changes to an employee report for Beaver Mountain Ski Area. Pushed up the code and let Debbie know that the new code was up and online.

Steve and Dustin were talking about new processes and using some new and fancy display options. After that, I helped Steve with some JavaScript calculations and some small page changes.

Wayne popped in and he gave a report about some of the server issues that happened yesterday. It sounds like a company was trying to pull multiple queries that had 2 million records per query. Basically, a log jam in the database. As we were talking about things, we were talking about moving from a purely transactional database, to a more aggregate type environment (aggregate meaning sums and totals vs individual transactions). Tons of data is awesome, but we need to limit the transactions and how many we are trying to chew up per bite. Some of the reports need to be re-written to be more efficient. Nobody wants to read and look at 2 million lines... all they really want is the totals, the counts, and the sums from that data. We may need to filter the data and better display it in a drill-down type basis.

Wayne was talking about DAO's (database access objects) and getting the queries in a more standard location and where to access those assets.

We are making progress and making things more stable. Sometimes when our users see an error, they instantly go back to what things were (older past errors) and then they fear the worst. That is just human nature. These are some of the growing pains. As a funny side note... Wayne was saying, other companies that seem light and fancy, they will have the same issues as they grow, their day will come when they are up against the wall and have to move from transactional data to a more aggregate type model.

Wayne was also talking about dynamic services vs just static boxes (dedicated servers). Basically a way to throttle resources vs setting up a static environment with specific resources. We were also talking about roll over protection and other mirror type values. We lightly were talking about how we may be out growing our current hosting company. We may start looking into AWS (amazon web services), Google, and/or other bigger players. Currently we are using Newtek and they have been awesome for years and years.

There was also some talks and discussion about a new pricing model based on usage, storage, bandwidth, requests, etc. We would love to get there but it still seems to be out there a bit. We were also talking about stats and then also projecting those stats out to our users. Some of this may require us to setup things per instance or per client. Random side note, I wonder if we were to go back to the drawing board and start with the end goal in mind. Would that change things? How, why, and how deep? Do we want that?

Maybe help our clients run based on sizes and needs. We grew from a small shared environment into a semi dedicated model and then into a fully dedicated model. We now have multiple dedicated servers. Wayne was saying something about Docker (spelling) containers and how to group things and somewhat create a virtual playground or virtual cluster per corporation or per company. Once we get them into the container of sorts, we could then expand that contain as needed. SaaS (software as a service) and how to expand and grow things.

Funny quote from Steve - "We need to get Wayne on a faster horse." Meaning, we may need to help Wayne get on an environment where he is not so limited (existing dedicated servers, structure, and physical boxes). Maybe we need to move more to the virtual playground.

Steve had some ideas about using more of the invoice homepage type mentality. Basically, we had an older report that pulled in the last 30 days worth of transactions. We totally changed that page to pull quick counts, graphs, charts, and sums. We then only show the last 15 records (really easy on the system). They users can flip/flop between daily, weekly, monthly, quarterly, yearly reports at the click of a button. All of the values are queried and pulled using a technology called AJAX (go get just the data and return without refreshing the whole page). Then, if they want more details (actual transactions), we have a number of other reports where they can filter the data to smaller and smaller levels. Steve would like us to do more and more of that to help eliminate the full detailed transaction searches. Great idea.

Towards the end of the session, I spent some time and built in a pre-check query for the advanced invoice line items search. If it has more than 100,000 records trying to return, it shows an error and requires the user to filter the details down a little bit. Apparently, this was the query that brought down data 8 yesterday for a bit. The company that was running the query tool was searching for over 2 million records in a single report. They were running back to back queries of the same size. That big of a bite created a data log jam in the database (table locking for joins then processing and doing calculations on 2 million plus records per query). That eventually caused us to reset the whole server. As a side note, that same query tool joins about 5 tables in order to get the results. If you do that for a couple thousand records, no problem... if you do it for millions and millions, at a time, it is a problem.

Working with Steve on some JavaScript to help with a new production build (internal builds) page. Lots of dynamic notation. Steve has been working on main flow and carving out some basic pages. He is then pushing things off to Dustin to help shine it up and make it look pretty. Steve wires it up (round 1.0) and then Dustin takes it to the next level (2.0). Good plan.

Eric popped in and had some questions on how to assign his sub special account tracking things to customers, payee/users, etc. After that, he and Steve were talking about future and upcoming projects. Steve was asking Eric about his backend skill sets vs his frontend design skills. We even got into some project management talks as well as backend database architecture. Eric has quite a few skills that are very marketable. We also talked about internal core projects as well as outside custom projects. Good conversation.

Steve and I were talking, briefly, about our direction for the future and near future. Good stuff. Our goal is to keep working on the system, building new pieces, refining some of the older things, putting a new coat of paint on the application (look and feel stuff), and figuring out the master plan of where we want to go. We have so many ideas out in the developer's notebook area... it would be so cool to gather all of that up and really make a plan.

The master plan could include things such as: database structure stuff (world building), graphical homepages, server structure stuff (universe level), fracture account ideas (things that we have learned and ways to break things into smaller and smaller pieces and settings), API socket access points, custom look and feel stuff, 4 different setting levels (corp/world, player/group, page/section, user settings), as well as additional rounds on balance sheet, elements of time, and subs of subs. This could also include all kinds of system stuff such as watchers, feeders, triggers and other ideas that are out there. That would be really fun, a huge project, but really fun.

On the morning meeting with Steve, Alan, Wayne, and Dustin. Checking up and getting caught up with what happened over the weekend.

Notes from Wayne about server stability and processes

Infrastructure - We have greatly increased this portion. We would like to fix how we deploy code to the servers. Currently we are just using FTP and are able to push code as needed to different servers.

Code - The last couple server issues have been code related (bugs, poorly written code and queries, or loose code). These code problems are currently affecting our servers as much or more than the infrastructure process.

See attached for a small proposal from Wayne about how to configure our environment. Wayne would like to look into Lucee vs ColdFusion. I put tons of notes on that physical PDF upload.

We talked about some costs and also options going forward. We talked about DNS (domain name servers - where are things pointed), SSL's (secure socket layers - https stuff), emails and texts, etc. We can virtually push some of the logging into the AWS CloudWatch services. Amazon also has some other servers that we could harness and/or use. Some of the other services are AWS Cost Explorer, AWS Budgets, AWS Cost and Usage Report, and Amazon Route 53.

Steve was asking questions about how we could make an adilas user group (power users - adilas community) that could be linked and/or joined to different companies or different adilas clients. Almost an extension of the adilas reps and consultants - who wants my skills, I have a power user account, and that could be tied in to anyone's account (based on permission and access). All secure, but also very mobile. Basically a way to separate users and clients.

We also talked about splitting up the databases (world building) into corp-specific databases (smaller single databases) and then working on the mixed or cross-corp queries. In the background it could be tons of different services and even computers, but in the frontend, the presentation seems singular and very streamlined and smooth. This also opens up more revenue options for our developers to help code cross corp or consolidated reports and such.

Some talks about future white labeling options and how we could setup adilas as a platform and then allow them to pay the AWS bills and they pay us for usage of the code.

The rest of the talks circled back around to the code and how we create and deploy our code. Lots of talks about automated testing and getting all of that stuff super stable. Being able to up-scale to handle bigger and bigger loads. Alan popped in and also brought in the possible option of down scaling as well. No one likes to talk about this, but we need to think about both side of the coin. If we are on a dynamic environment, we could virtually scale up and/or down. Once again, it comes back to a two-part puzzle... you have both code and infrastructure.

Alan was talking about how to encourage our developers to run more of a test driven code structure. This will be a cultural switch. If we make it so that the system becomes the bad guy, we could help to change that culture. We've done this before, when we first introduced permissions and such. We talked about training, tooling, and guidelines to help some of these developers. Most of the talks today have dealt with changes to infrastructure - we also know that there is possibly a bigger conversation about the code development side of things.

Where are we going and/or heading? Eventually, some of the adilas functions and features will become components and virtual standalone pieces (modules of sorts). We need the flexibility of a Legos type scenario... multi interlocking blocks that could be mixed and blended as needed.

From Steve - I'm seeing lots of our wish list boxes being checked with these new proposed changes.

From Alan - This seems great for scaling. Hardware is one of the hardest ways to scale. If we could turn it into a service, it becomes easier to manage. Alan was also talking about scaling up and scaling down. Make sure you can go in both directions. How much weight are forced to carry... being able to absorb or extend as needed.

We can make the whole presentation more seamless. Currently, we send clients to data 10, data 11, etc. If we go more in this direction, it just runs more seamless and we scale things in the background as needed. In the background, we almost need a platform babysitter that helps us know what is going on and/or what is available.

Our clients tend to like - our pricing, our possible functionality options, and how easily we can customize things.

Dealing with timelines... We are seeing this transition between 6 months to a year. Maybe even more. We will start on it immediately, but it still may take some time to roll these things out. Also, we can only see so deep, there may be some unknowns that hit us as we get into things. Alan was saying some of the fun development sayings such as the last 10% takes 90% of the time and other things like that. It always gets crazy. Slow and steady wins the race. Lots of good things on the horizon.

On the morning meeting. Dustin was on with me in the morning. Eric came on around 10 am to 11 am. Eric and I worked on some logic for the sub special account tracking stuff (loyalty points and gift cards). The other project that I was working on was some black box and custom barcode generator mapping for a client. Took over three main pages. The PO lines items, the view parts page, and the add/edit parts page. All of those pages have a number of links to the barcode generator page.

Meeting with Steve and Dustin to start off the morning. Dustin had a couple of questions on ways to track some of his internal code changes. We talked strategy for a bit. Steve then had a question on a client's custom label. It was duplicating one of the fields. We dug in and found that it was a sub inventory attribute that was virtually sharing an id number with another sub inventory attribute. It was appearing to duplicate the data due to the numbering of the attributes. Random error. We went in the backend and fixed it. We haven't had any other complaints about that, so we are assuming that somehow both attributes got assigned the same reporting number.

As Steve and I were fixing the sub inventory issue, we were talking about sales, customer support, and how we are hoping that these new server configurations are going to help us out. We also talked about getting someone to help Shari O. - she is getting buried and needs someone to help. We also talked about some other ideas to think about while we are breaking up the bus (analogy of getting people off the bus and onto their own motorcycles or cars - aka world building). Here are some of the quick notes:

- What about mini options for AWS servers... Currently we have multiple dedicated servers (with fixed number of processors, RAM memory, and fixed hard drives for storage). What if we took those bigger boxes and virtually broke out a new virtual instance for each of our clients. If it could work, it would be almost like a mini virtual dedicated box per client. Just an idea.

- Steve would really like to split out users from corporations (allows users to exist as their own entity and also as part of a master list). Then, we could bridge people over and across and allow users to jump between corporations as they get assigned. We currently can do this, within a single box or cluster. It would be awesome if we could do this on a universe or global scale. Any user (has a single account) and could be interconnected and/or have access to any other corporation (world) based on permissions and being bridged over. Think of home planets and bridging people from worlds to worlds. (digital passports and what not)

- Currently, we (adilas admin) are the only ones who can bridge users between corporations. If it went out further... we could allow individual parties to allow/invite other users to come in and help with any projects and also set connection durations (how long they could virtually stay). If we empower the users to create those relationships, that takes the load and the liability off of the admin adilas team. Good stuff.

- Steve really wants to help out workers and/or dependables

- We would really like add some visual upgrades - CSS and settings. As a side note, settings are going to be huge going forward. We are seeing at least four levels of settings - corp (world), group (system players), pages, and user settings.

- Steve and I were looking at some stats that Wayne had gathered for us... crazy to see those stats and this is just one month from the data 0 box. We would love to see all of the servers and all of the stats, side-by-side, and compare. That would be crazy.

- The deeper we get, the more settings and being able to toggle things on/off (custom setup options) are going to play in. We were even talking about new settings for ecommerce and companies that allow for new customer/client accounts to be setup. What fields do they want to show/hide, what ones are required, what special instructions, what names or aliases, what sort order, etc. Everybody wants crazy deep levels of control on how they set things up.

- Steve and I talked about the pros and cons of the black box options... on the one hand, we can configure any page to do whatever we want. On the other hand, if we go black box vs building a new setting, we have to do the same thing over and over again. Sometimes the speed of the black box option actually creates more work later on. The longer route is building a setting, but it then becomes easier to manage that later on, plus less duplicating code.

It's Monday. Josh, Dustin, Steve, and I were on the morning meeting. Josh checked in and we set up some time to work on merging in his discount engine stuff. We added some new permissions and created a new help file for him to populate. We are hoping to get all of his code rounded up and populated within the next couple of days. Good stuff.

Steve's summary from January - Mrs. Shari O. needs some help. We've got that going and Pat will be helping out. We need to make it easy, pretty, and powerful. Steve would like to circle back around and then we need to do some look and feel stuff (make it look pretty). We will keep building out the functionality but we really need it to look nice and appear more simple. If we can get the current model, more spiffy (nice looking), we can really wind some things up. It is a very abundant model. The future of SaaS (software as a service) is customization. People want to start very simple and slick but as they go, they start looking for more functionality and eventually really want it to be their way (custom code and customization).

What do people do the most inside our system? We can pull in stats from all of the servers and then look at them (the stats) side by side. We could then have Russell go in and help us with some cool look and feel on the top 10 pages. Once that is done, we could keep drilling in deeper and deeper.

Alan popped in and gave us a report. Steve and I were working on different projects. I'm working on checking in code that Will did for a thing called transitional PO's. The new PO type is between an order/request (not tied to inventory) and a live PO (fully tied to inventory and payables). The new transitional PO's allow for pre-payments (assets or pre-payments on inventory) and will be tracked on the balance sheet differently. The project has about 22 pages in it. Just going through and checking out code and adding my own flair to it.

Dustin and I were on the morning meeting. Pretty quiet overall. I started working on a custom invoice for shipping and work orders for a client.

Everybody is feeling the pressure. Lots of requests and requirements. Steve and I were talking about priorities and how to manage the amount of inflowing requests and requirements. Sometimes it is literally disabling in some ways. Pretty crazy. I'm so thankful for the people who are helping but even that is a challenge at times.

Dustin and Eric popped in and reported. Eric is feeling swamped as well. We had some more talks about priorities and what not. Lots of moving pieces between internal projects, customer projects, 3rd parties, bug fixes, maintenance, and client demands. Everything tends to work out.

I got into the meeting a little bit late. Steve and Dustin were working on some things. Once they were done, Wayne began reporting on some of the new AWS (amazon web services) things. We were talking about moving some of our existing pieces (server stuff) over and across to AWS and then tweaking things from there. Lots of options to help optimize things. There are so many things on the virtual to do list... we'll just get started and then go from there.

We are also excited to start seeing real costs and real usage patterns. This is both internal and external.

Wayne and I spent a couple of hours going over tons of things... data servers, content servers, images, corp-specific folders and storage, session stuff, security hashes, Windows specific code, and tons of other things. Super good meeting.

Steve, Josh, and I ended up having a discussion about the new discount engine (new code that is being released) and wanting our clients to move from Classic to the Snow Owl theme. We have so much more functionality on the newer Snow Owl theme. Some people are too busy to switch, some are just unsure, some think there are issues, etc. We would really like to use the discount engine to help us transition those users over to the newer look and better settings.

It takes a village to do some of these tasks and things. Delegate, empower and get out the way. We keep building and tearing things down. That is part of the process. We have some great people all around us. Let's keep feeding those fires. Yee haw!

Busy morning. Dustin, Steve, and I started out the meeting. We then had Alan join, Eric join, and Josh as well. Steve and I worked on some new code together. I then passed it over to him to test it. Alan reported on where he was at on certain projects. Josh had some questions for Steve and Eric and I worked on his sub special account tracking project (loyalty points, gift cards, etc.). A big majority of the time was working with Eric and making sure we could get his new database install up and working. Because we brought things up from the ground up, it uncovered a few things with our current project. Good progress all around.

Hopped on the morning meeting with Dustin. Just the two of us were on there for the first part. Dustin had some questions about some of the reports coming off of the cultivation homepage that he and Steve were working on. We ended up talking about having a plan and really knowing where the different pieces either are and/or should be. Knowing is half the battle (old G.I. Joe quote). If you know what should happen, then you could go back and actually check that. If you don't fully know, how are you supposed to check and/or verify what is happening. You've got to know and/or have a map of sorts.

Wayne came on and gave a small report. He is making good progress on the AWS stuff and reported on some custom tags and ideas on doing unit testing using a special framework and program. Most of our testing will be in ColdFusion but some of it may end up being in Java or some bigger or more robust language.

Monday morning... here we go again.

Steve, Dustin, and I were on the morning meeting to start with. Each of us has our own to do list stuff. We touched base and then started working on our different projects. One of my projects for today is to take all of my post-it notes on my desk and put them all on one giant to do list and/or tick list. I only made it through a couple of post-it notes before I got pulled off that project to help with another one.

Eric joined the meeting and had a number of questions about the sub special account tracking project and some decisions on how and where to do the safety checks. We got in to it and decided that he would need both local validation and server-side validation. We talked about mixing JavaScript (local) with ColdFusion (server) and how best to do that. I showed him some examples and pointed him in the right direction.

Calvin joined and had some questions about direction and working with multiple servers. He is working on the adilas label builder app and wizard-type project for custom labels. Steve and I setup a demo for tomorrow. Calvin also needed some help accessing some live data to do some tests and what not.

After that, I went back to adding in to do list items on the big spreadsheet. I paid some bills and light tech support stuff. One of the tech support questions was dealing with custom field settings for customers. This has been somewhat of an issue since 2016. Long story made short, we added a page where a user can change names, show/hide, sort, set defaults, require, etc. for basic customer fields. That options exists on one page... it also only applies itself to just one page. The problem and/or request has been, why don't you cascade those settings all the way through the system? To answer that, I would say, we would love to... it just takes time, planning, a goal, and funding to get it done. We would love to finish some of those things up.

Towards the end of the call/meeting, Steve and I talked briefly about priorities and needs within the system. Lots of demands and we have to manage the resources based on both internal demands and external demands on the same resources.

Steve and I were on the morning meeting. He is still feeling kinda sick. We worked on a small query for his code and then tried to work on Calvin's adilas label builder. Steve's copy of the program is stuck in a login credential error. We tried installing and uninstalling the program a few time. We will most likely have to reach out to Calvin to see what to do. Along those lines, I also made some notes on my to do list about some other tweaks that may be needed.

I spoke with Shawn, Eric, Bryan, and Dustin at different times during the morning session. Some were simple questions and others were trying to setup times to work on certain projects. Lots of email stuff. I used the last part of the meeting to look over new state and federal tax withholdings that Shawn submitted.

Paying bills, working with Shawn, pushing up code for Dustin, and checking new state withholdings.

Talking with Steve and Dustin about options on black box...

- They were talking about using settings saying use custom, use core, use x, y, or z... we may have to wrap pure black box code with dynamic populating options (which option to use).

- We could really use a way to help show if the corps have black box options. Maybe even a flag (under the covers or in the hidden HTML) that says whether or not it using black box and/or core functionality.

- It may also be helpful if we could allow users to pick and choose if they want the black box option (full custom), the core adilas option (non custom defaults), or an industry specific option (build these options specific per industry).

Wayne popped in and was reporting on some AWS stuff.

- As we start moving over to AWS, a lot of the switching between test and live (URL stuff), is kinda going away and things are becoming more dynamic. Mostly dealing with URL, web addresses, domains, and path stuff.

- We talked about files and media/content storage and what to make publically available and what not to. We also talked about settings and adding in public and/or private boxes per corps (places to store things). We also talked about allowing users to put timelines (expiration dates) on sharing files and such. Say something like, I'll share this file with you for two days or I'll share this file for a couple of hours, etc. Once the expiration date of the URL or file happened, they would be denied unless they opened it back up. Kinda like opening and closing windows and doors for specific time periods.

- Wayne was talking about non language specific functions that we could run at any time. He was calling them Lambda functions. Very similar to an API socket connection or API call. Basically allowing the code and the response to be run using different code languages (mixing and blending coding languages).

- Wayne was also talking about off loading certain API socket calls and groups of calls to certain sub processes. Splitting up the flow and traffic based on needs and like functionality. Basically specializing code to be more effective and grouped.

- File versioning and auto file versioning - comes automatic with certain boxes out on AWS.

- Designing a life cycle process of sorts (putting things deeper and deeper into storage). Maybe use the access time (when was it last asked for or used) as the key indicator. This could be done if we need to mange active vs passive storage. We talked briefly about the analogy of water turning into snow and then going clear to ice. This may also come in to play with compliance, storage, active/inactive accounts, and long term cold storage.

- We spent quite a bit of time going over how the transition between our existing model and where things are headed and how to help with that transition. It got us into some discussions about master corporation lists, master user lists, and what permissions where set per section. Steve joined in and gave us some good ideas while we were talking about breaking out user/payee/employees off into their own entity.

- We ended with some conversations about world building, universe level, cluster and galaxy levels, world levels, etc. Fun conversation and lots of upcoming options.

Steve and Alan were talking about frontend automation on the credit card side of things. We are looking into API sockets for USAePay (our credit card gateway that we are using) and being able to pull reports that show customer credit cards that have expired, will expire, or expire during a set date range. It would be super cool to get this information in order to help our billing department.

- Steve is really excited to see what the AWS (all of the stats and such) side of things will bring to the table. We really want switch our billing based on storage, throughput, bandwidth, requests, etc. That would be awesome.

- Two parts, the gateway side and the adilas side of things... we need the header and app side of the communication process (extension of the invoice due date project). The goal there is to use adilas and be able to communicate back to the users (different companies) and let them know if their invoices are getting to a certain age. Based on settings, the goal is to warn and help get a payment and if needed, to shut off and prompt for payment before usage resumes. There are more details, but that is the general idea.

------

Got on a Zoom session with Calvin. He was having a problem with an existing API socket. As he was looking deeper, we recently made a number of changes to that page back in January. It is dealing with sub inventory, searches, and calculating sub inventory quantities. I scheduled an hour, later today, to look into his question.

------

About 11 am, Steve, Bryan, and I got on a meeting to look at Bryan's adilas community projects page. This is an area where adilas users and consultants can submit and vote for what projects they want us to work on. Basically a way to get outside input on priorities and what is needed and wanted. Steve sees some of this as each user having their own little individual user account (almost outside of adilas). They then could do whatever they need to outside of any specific corporation, just as a user. When they want to go in and do some work, they would need to enter a corporation and/or world. Basically creating a separation between users and worlds (adilas accounts).

Some of our conversations turned to possible misuse, abuse, rants, and managing potential problems. In a way, it is almost like opening up a virtual forum and public facing entry point. We also talked about design and styling out the page to make things look more modern. It is crazy how deep, sometimes just a single decision goes to crazy deep levels, and it is hard to see what is going to happen. Lots of cause and effect decisions. Steve was talking about how the look and feel almost helps guide the process. How well does it show? Do people want to spend time doing something that looks old? If it looks modern and smooth, would they use it more? What do people accept? What do people want?

After the discussion about look and feel, Steve ended up back on the master user accounts topic and being able to use a single sign-in type interface. This deals with users being able to independently use certain functionality outside of an assigned corporation. We also talked about being able to submit projects and notes and having some sort of sign-off and/or approval type process.

We also talked about timelines and being able to show other projects, ideas, completion rates, what project are on target and/or in progress, and other ways of communicating as to what is going on. Long story made short, we love the ideas and concepts, but it still needs some loving and direction. Eventually, we want to open this adilas community forum and community projects to all users and consultants.

-------

Talking with Wayne about the new open/general login process. He was talking about an open id (somewhat of a master user id - a hashed username string). We were talking about questions about what happens if a user gets setup but hasn't been associated to a specific world and/or a corporation? How do we allow those assignments to be made, requested, and eventually approved. Wayne was talking about an authorization queue and a way to approve and allow access to certain users.

------

Worked with Dustin on adding new entries in the sub GPS/RFID tag table. This is a sub of elements of time. He is tying things into his cultivation and production pages.

Joined up with Steve on the Monday morning meeting. He was showing me some new pages that he was working on and using some prebuilt CSS templates that we purchased. Russell Moore got us started with those CSS templates a few years back. Steve has been in there playing around and is grabbing code and pages and plugging in real code and database values. It is starting to look pretty good. As a side note, a couple times today, we have circled back around to prebuilt templates and what they offer.

Steve and Dustin were talking about some of their combined efforts and different demos that Dustin has been giving and doing. He has done a great job and is very easy to work with. That is a huge plus.

Calvin joined in and had a few questions. He also helped both Steve and I get the latest versions of his adilas label builder wizard. We worked with the label editors and then also gave Calvin a few change order to do list stuff. We would love to get some data formatting functions to help make the data look good. The other major topic was talking about 3rd party solutions and how we secure those pieces. I told Calvin that I would work with him on what is needed and how best to get the desired outcome. We are planning on adding a section for Calvin and MyEasySoftware in the adilas 3rd party solutions section.

One little nugget from todays talks and discussions was: We may be better off getting one or two key persons trained up on certain features and implementations and then allowing those parties to charge or get paid to help setup the others who need those pieces. It helps get specialists and also really cuts down on the tech support required to do harder or more complicated tasks and processes. The summary is: Get people to pay for value added services, especially somewhat technical or complicated setup or in-depth processes vs trying to teach everybody how to do it on their own. The other option to that, which would be nice if possible, is to make the setup and/or processes more simple and intuitive. Somehow we need to monetize some of these deeper tools. Either charge for setup and training or increase the monthly reoccurring.

Wayne joined the meeting and had a few questions. He and Calvin chatted about AWS, windows services, and how they may be able to use AWS Lambda functions to do similar things that we are doing under the current Windows server model. It got pretty techy. We setup a new permission for Wayne to use in his open id user pools and how to grant or deny access between open id users and different worlds or corporations.

Steve and I did some more work on templates and getting a good starting place to work from. Steve was talking about how awesome it is to use prebuilt CSS templates due to the fact that you start from a working picture (static or fake data) and then build in functionality from there. We did a code merge for Steve and I had to help out with some page view icons for some of the new pages.

Towards the very end of the call/session, Wayne popped back in and had some questions about changing the MySQL data engine from MyISAM to INNODB type tables. Techy database stuff. He also had a question about the scan and add to cart process and how complicated it seemed to be. We talked briefly about some performance tuning and options. Basically ways to help go in and split things apart and/or speed up certain queries. Afterwards Steve and I chatted and talked about some of the cool things that are coming down the pipeline. Keep moving forward.

Steve and I were looking into a barcode scanning question from a client. We went in and logged in and looked around and didn't see anything out of the ordinary. We changed the item names and looked in the backend database to see if we could see anything. It seem like all is well. After that, Steve and Dustin started working on some of their production (mini manufacturing) processes.

Eric joined and had some questions about adilas API socket settings and being able to turn certain things on/off through the 3rd party solutions. We also setup some time to work on code review for his sub special accounts stuff (loyalty points, gift cards, etc.).

Tech support and helping Drea out. Wayne jumped on and helped with the backend tech support stuff. Basically, a company was missing a couple of records. We looked and the database had no record of them. Even the auto id numbers totally skipped them. From our point of view, the system should have given them an error message saying that a certain actions were not possible. Anyways, we did some research and got Drea as much information as we could. She will have the client call back two of their customers to see if they could get some data from them. There is no record in the actual database.

Wayne and I then did a little session where he wanted me to look up some small bugs that are showing up in his server error logs. I recorded one of them and we looked at a couple of other ones. Small little issues.

Steve, Alan, and Dustin were on the morning meeting with us. Steve had some questions about a custom gram control that he was working on. Alan was reviewing with us his work with USAePay and helping to automate the invoice payments and reoccurring invoice stuff. The conversation trended towards the use of the external alternate id number and how those fields get used. We are already seeing a need for a one-to-many relationship between normal id's and the use of the external alternate id number (id numbers from outside parties and/or outside systems). Very interesting.

We ended up talking about custom needs, settings, and how to help direct people in other areas. We spent a little bit of time talking about building generic tools and generic database tables vs industry specific and vendor specific tools and database tables. There are pros and cons between both. Generic helps cover the basis but sometimes takes a little bit longer to implement and design and develop. Specific code could be very fast, but you then need to somewhat duplicate pieces as things grow and expand (different parties wanting the same things).

We also got into some talks about frontend development and backend development. Look and feel, user interfaces, flow, animations, and design vs functions, code, logic, database stuff, and backend tools. So many people judge our entire application based on their first impressions (what they see). There has to be a good balance between good tools and good looks.

Working with Dustin on some JavaScript and advanced options. We spent over an hour looking around and trying to figure out how to cross tie some application pieces together. It got pretty deep with some of inspinia and bootstrap code (special CSS templates, JavaScript, JQuery, and HTML output pieces).

Wayne popped in and gave us an update on where he is at on the AWS stuff. Lots of new moving pieces. Our goal there is to get the existing code working out in AWS land before adding all kinds of new code to the mix. After Wayne left, Steve and I were talking about some of the changes in the wind (virtual direction and force of the upcoming changes). Pretty interesting. We may need to get some other players involved and then figure out where they are going to fit in and who wants to do what. Lots of options.

I came in late, but Alan and Steve were looking into some Metrc API sockets and matching up things between systems. After that, Alan and Dustin got into some of the Inspinia datatables and how to interact with some of those new things. Alan was able to help Dustin out and point him in a good direction. Steve and I then looked into a balance sheet item called inventory in transit (asset). This is part of the math and code for the balance sheet. Eric popped in and had a few questions to help with his sub special account project (loyalty points, gift cards, etc.).

Wayne was talking about some other options that are available through AWS. Top level firewall rules, XSS (cross site scripting) validation, queues, topics, reminders (SMS), etc. Wayne predicts that our ColdFusion pages will become smaller and more efficient as we offload some of the other code functionality to other tools and/or other applications. So many options. We also talked about new possible options for using and doing custom black box pages as well as custom themes (global or industry specific). We were talking about all custom code and file storage (photos, scans, images, files, media, content) per corp and being able to charge for that. That really takes it down to the corp level and charging for storage and usage.

Emails, paying bills, and light tech support.

The morning meeting started with Steve going over some of his plans. Normally he has been taking Wednesday's off, but he had a couple of small questions. He is building a new page to help cross tie PO's with balance sheet items (some special tax project of sorts). He is using some new CSS templates to wire things up. He is getting good and is able to start seeing his way through the entire project. It is pretty cool to see him getting the ideas, concepts, and then being able to mix and blend the pieces to get the output that he is looking for. That is exciting.

Dustin was on with us as well. He is researching backend classes and API options for working with datatables for some of his projects.

Steve wants me to start working on the transitional invoices and adding the inventory in transit (asset) piece to the balance sheet. I went in and added the new code. It wasn't too bad, most of the work was already done, it was just showing it up in the correct place on the report.

Eric joined the meeting and had some questions about 3rd party solutions and push vs pull type requests. Most of our 3rd parties want to get data through the API sockets as a pull type request. We do have some that want the data pushed to them as things change (just in time or at the source of the changes). We talked about the differences in developing and also the differences in costs. Eric will be helping some of his clients move more towards the push type technology. We get better results that way and don't get flooded by too many pull requests. It is actually better for both parties, it just takes a little bit more planning and coding on the front end. Eric will end using that as a small revenue stream depending on what the clients want.

Wayne and Alan popped in. Wayne let me know about a couple of pages out in the adilas marketplace that were not very secure. I ended up going through a number of pages and adding in some URL validation to help prevent XSS (cross site scripting hacks).

Meeting between Kelly, Steve, and Brandon. This was a discussion about the current state of adilas, wishes, hopes, disappointments, frustrations, needs, wants, and dreams.

Kelly has been involved since 2010. She has trained, trained our trainers, done tons of tech support, and opened up tons of accounts on her own. She would like to help drive the business but feels like she doesn't have much say.

Steve was talking about payment and commission structures (monies paid and owed to Kelly). Kelly wanted to know, what is our admin structure? Steve said, well, we have dependables - people who just help and work with adilas. Kelly would really like to see our organizational structure.

We are seeing different people and they have different skills in different places... How do we mix and blend those pieces?

Kelly proposed a basic model... see graphic. She really wants to build out a standard structure. She sometimes get very frustrated by having to provide customer support for things that we are adding and doing in the background.

Question: Is it the size of a company thing or is it personnel thing? Kelly came back and said - It sounds like you need a motor (a person), someone to help drive the ship per company. We are starting to see that there are some dependencies. Some of the known dependencies are good consultants and good developers. Steve said, our solution is a tool, we need to find those that want to use our tools, in whatever state (our system) it is in.

It kept coming back to different people being good at different things. Nobody can take adilas from a to z. Currently, it is a very loose model right now. Steve kept coming back to having a person who helps to drive the adilas implementation per corporation. Kelly wants it to be standardized. She really wants some kind of structure to be able to hand off to a company so that they can run with it. Currently, there are a lot of moving pieces.

From our side... every corporation runs slightly different. That makes it really hard to setup a perfect standard and/or structure. We currently are having some of the best success with people who really want to jump in try and love to learn things. Kelly really wants adilas to come up with a more standardized structure - do this, do this, do this, we recommend this, ok you're set. The easier that we can make it, the easier we can get more people on board.

Adilas - all data is live and searchable - we need more options to get at the data better. Kelly wants all of the pieces live and searchable. We have a good start, but there are certain places that really still need some loving. Kelly wants to know what our plan is? What about funding and going out and trying to raise monies? Currently, that door is not an option. We are really trying to stay within our means. We don't like owing money and living under that debt.

We talked about some of the challenges that keep pulling at us. Tons of projects and tons of demands. We also talked about accounts receivable, reoccurring credit cards, and constantly chasing payments. We talked about some of the trouble makers (hard clients and customers) and what to do with them. We talked about online bill pay stuff and how to get the monies that are owed to us quicker.

How do we market our product? New sales, marketing, word of mouth, referrals, etc. The power of a good consultant. Those who have a good consultant seem to be able to keep it going. Another place where we sometimes struggle are in the developer arena. Those skilled persons are very critical. That seems to be the squeeze point (trained people and who does what and how do our people know what expect and who to ask).

Sometimes you can oversell things by saying, you can do anything. Kelly would really like for the process to be more standard and structured. Basically, putting training wheels on the system. Maybe we need an outside party to really run with their own standard process of setting up a client. It may not come from us (right now). It would be so awesome, if we could get people going without a great consultant. Turn it into a step-by-step wizard and/or step them through the paces by virtually holding their hands (Dustin calls it guardrails). If it gets better and better and faster and faster, it will become more intuitive and will take less handholding will be required. Maybe show a 1,2,3,4 setup process and/or show checkboxes to show what is needed. Help guide the users through the process.

Some people don't want to spend the time to watch a video. They want to just guess and/or fake it. There are also some who just want to be shown, by a real person. They almost want it so, so easy, that it isn't funny. It seems to come down to who wants to fund and setup these services. There are tons of things that are needed, but who is going to build it and who is going to fund that development? It gets crazy. Sometimes it is so much, we almost overwhelm people. It would be nice if we could turn things off, turn other things on, and/or limit them in certain ways.

Who wants to set up their own processes, because everything keeps changing? It gets tricky. We need it, but who is going to do it? Plus, it keeps changing and changing and has cascading cause and effects. It seems to be never-ending.

Kelly wants to know who is driving this ship and who is taking care of the financials? We keep flexing and rolling with what comes.

We may need more exports to MS Excel and/or CSV. We need access to the underlying data. This could be datatables (prebuilt exports and sortable tables), this could be normal exports, etc.

If I were a lifer (in it forever - a lifer), how would that look and where would it go and how would I be a part of that? Steve would like to put adilas in a trust - no employees, just dependables. There will always need to be a caretaker and/or person(s) that help it keep going, but it could run light and get direction from those involved.

Does anybody know adilas all the way through? No, we don't have anybody that really knows it all the way through. Kelly wants to see things get more organized and/or stable. As a side note, we know that we need adilas university (training and support) and the adilas marketplace (adilas world - who is able to help and who can do what). Kelly feels like we need to drive in a direction (goal oriented) vs just reacting to the pull of what is happening organically. Currently, we have outside independents and they tend to max out and growth is somewhat slow. The word "evolution" kept coming in and how it relates to the business model.

Different areas... communication, training, design and user interface (look and feel), development (code and functionality), and other services that are needed and/or offered (open marketplace). We need to keep bringing up all of the pieces. Keep finding people who want to play and are able to play.

As we get more developers... some of the pieces become less stable (different flavors and/or code quality).

There are a lot of clients that are looking for a solution. At some point, they will take what they have to as they keep looking for something better. Interesting.

There is currently no handbook for adilas. There is a lack of training materials and structure. That is a known issue that we are facing.

Trying to catch up on emails. Dustin was on with me this morning. He had a couple small questions about some JQuery stuff that he is working on. Mostly, we were working on our own stuff.

It was just Dustin and I to start out with today. We pushed up some files for him to test live. I was trying to track down a small bug that Wayne had passed over to me to look at. It was something to do with code out in the adilas market (adilas world). Wayne popped into the meeting and gave us a small report as to where things are at with AWS transition. After that, Eric and I went over where we are at on the special accounts project. I'm trying to push on that project and finish up the code review.

These are just general notes, but it was mentioned earlier today that one of the problems with our model is actually allowing the clients to control how much effort is put into custom code. They don't actually code things, but they do fund things. Sometimes they opt for the cheap route vs the best route for all parties. Sometimes this has an adverse affect on poorly written code or bad code.

Another small topic from today was dealing with the size of the shared database structures. Some of them are getting very big. That makes it hard for certain queries to run efficiently or as optimized as possible. In the very near future, we will be pairing the database schema (tables and field names and values) into a smaller per corporation type model. That should really help with some speed and performance.

Towards the end of the session I was working on a new application form for the state of Texas. This is used by trailer dealers and applying for special farm license plates and registration stuff. We already had this form in place, they just have a newer version that we had to code.

On the morning meeting with Dustin. He had a question about one of his custom pages. We got into it and worked on a dynamic variable for some of his JavaScript pieces. It got pretty deep as we had to find a special column number that was used to get special data that the page needed. We had to mix hardcoded columns, conditional columns, and an unlimited number of dynamic or user-defined columns. We had to find the correct column number that held a special batch number and that was dynamic as well (a mapped setting). Lots of moving pieces. Anyways, he nailed it and we got it done. We also set him up with some light FTP access to one of the servers to do some live testing. Good stuff.

Wayne joined us and had a few questions and some updates. I then spent the rest of the session finishing up the new Texas application for farm use license plate form and PDF. I tested and uploaded files to all servers. Light tech support and emails.

We did a code merge and sign-off between Dustin and I. He has been working on some new settings, look and feel, and some cultivation pages and functions.

Wayne joined us and started showing us a difference between the existing Application.cfm and Application.cfc. He was showing us some code on session start, on page request, on page load, on request end, etc. Lots of cool access points for the application as a whole. Economy, efficiency, consistency, etc. Lots of good stuff. We could pick up the gains and even gain some performance enhancements.

At the end of the session, Wayne gave Dustin and I a few pictures and short peak into his life and what he and his family do for fun. It was nice to put names with faces and see what makes everybody tick. I really enjoyed that.

Working on some code merges and tax withholding updates from Shawn. Got a call from Shari O. and Dustin and I had to do a quick fix on a page that was pushed up earlier today. Minor tweak, but somewhat urgent.

Wayne pretty much ran the morning meeting today. As soon as I joined, Wayne, Steve, and Dustin were already on. Once we got started, the entire session was dealing with updates and upcoming changes that are available to us out in AWS (amazon web services) land. Kinda interesting.

We started the morning talking about photos, scans, and images and how those are stored currently. We moved to media/content (outside files) and then talked about ways of doing that kind of storage in the new environment.

Wayne was showing us how quickly he was able to copy whole servers (existing dedicated boxes at Newtek) over to the AWS environment. He was also showing us how some of the resource management (CPU's, memory, and load balancing) were working as he spun up other instances. Very quick and very powerful. We are going to be able to speed up our time to market by leaps and bounds. Lots of talk about current model, options, and needs vs upcoming/future model, options, and new needs.

There was quite a bit of time spent talking about existing flow, hot fixes, FTP (file transfer protocol), and code repositories and deployment options. Lots of talk about the advantages of building a testing library and running tests and unit tests to increase the level of comfort, efficiency, and confidence for the developers and the clients (system users).

Wayne was using the term "tooling" and using the new tools and/or tooling environment to help standardize environments, processes, and expectations.

We went over some possible problems with incomplete data and who is going to help mange and/or watch what pieces of the system. It really will be, and currently is, a giant team effort. We need all of the players to keep pulling their weight and doing what they do and how they do it. More and more talks about teams and cross training those teams.

Meeting notes. Steve, Brandon, Wayne, and Dustin were on the meeting. Wayne was showing Steve and I about some cool image manipulation options. The site and tools are called Thumbor - image manipulation. It was capable of pushing up an image and then running all kinds of cool tweaks to the image, on the fly. Things like cropping, scaling, specific file sizes, grayscale, colorizing filters, etc. Pretty cool. Our goal there was to talk about ways of using existing tools to eliminate how much processing we make our ColdFusion servers do. Currently, we do all of our own image manipulation and storage on a per server basis. Just some ideas and concepts at this time in the game.

After Wayne and Dustin left, Steve and I had a good discussion about where are things at and where are we headed. Both positive and potential dangerous and/or scary. Open conversation, no specific takeaways. Here are some of our notes:

- Defining strengths and weaknesses and then working on both

- Talking about the new AWS stuff - pros and cons

- The skill level difference between an adilas user who is a developer and a normal or non adilas user computer developer - there is a difference. A lot of our stuff has a culture and all kinds of cause and effect relationships attached to single decisions, setting changes, and/or wants and needs. Interesting.

- Your eductaion and expierence help you on your approach and/or your angle of attack

- Revenue is not what you get to spend

- We have a bunch of things that are partially done - finishers wanted

- We talked about the scary pieces... These are mostly the unknowns... this could be on complexity of the AWS side of things and/or the unknowns on normal operational costs (speaking of AWS stuff).

- Steve and I spent quite a bit of time on - Let's make a plan - this is huge. We really need to see what and where we are doing and going. We know that the plan changes from time to time, but we need something to help us direct this thing as we move forward.

- Scratch built vs pre-fab or mash-up options. We have been pretty spoiled and have built our own scratch built pieces for years... we can't keep up with demands if we keep that same mentality. We are being somewhat forced to start using pre-fabricated pieces, outside code libraries, and outside products to create a mash-up of sorts. As a side note, even through we like scratch built features and options, one of the adilas goals is to become an API socket option (aka a mash-up option) for other companies. We want to build out the tools and then let others (individuals, companies, and even outside 3rd parties) consume the adilas API sockets as needed.

- One of our concerns is, we spend hours and hours of our time on meetings and talking about possibilities. Technically, this is just R&D (research and development/design) stuff but it takes us away from other tasks (opportunity costs). We love it and we still need it. It comes down to a balance and a plan.

- Talking about business and the different balances needed to keep things going and in check. Steve and I talked about an emerging 3-way balance between clients, systems, and education. Each of those main topics branch into sub topics. For example: Clients may branch into sales, funding, shear numbers (how many clients), and market demands. The system side of things seems to branch into user interface, functionality, features, settings, permissions, development, and tech. The education side seems to open into documentation, ease of use, instructions, guard rails (don't let people fall off), just in time learning, and the need for good reps and consultants and other trained individuals. Very interesting. Shannon and I had a similar conversation the other day. See this link for more information: https://data0.adilas.biz/top_secret/time_web_gallery.cfm?corp=748&id=4506

Helping Dustin with a code merge and light clean-up. We had to do some manual cross checking, but got the files merged in and uploaded to the servers. Spent the rest of the time doing clean-up, recording notes, and writing an email to Wayne requesting that we get a plan in place for the transition over to the AWS (amazon) stuff.

It must be Monday... We started out on the morning meeting and only Steve and I were on at first. We chatted about the transition over to the AWS (amazon) stuff. We have a number of questions and aren't really sure which way to turn. Steve needs to provide some of our clients with an answer, can we service them or not, and we need to know how long it will take to get the AWS stuff fully up and running. Lots of unknowns, but some great potential. Part of us wants to return to what we know (older stable ground) and the other part of us wants to keep pushing forward (new and uncharted but promising ground). It creates an emotional battle of sorts.

We switched gears and Steve had some questions about a project where he is tying in balance sheet numbers to vendors. As part of his project, he was trying to come up with a switch that we could flip to help us know if a vendor was an inventory (parts or items) vendor or just a normal vendor. As we talked about it, we decided to take it out to an app type level (the 12 main system players). We talked about that and Steve liked that idea. I got him some code to help him get started. It is amazing how much, as we keep going, that the system keeps organizing itself into main player groups and what kind of relationships are needed per system or main player group. Very interesting. Almost like it likes to be organized into groups and related functions. We sure have learned a lot along the way.

Alan joined the meeting and we were talking about some of his projects. He is still working on automating some of the reoccurring invoice stuff. We also talked about having Bryan work on the dynamic field names and settings per main player group. That is pretty deep and we may keep it tabled for now. Also, as we were talking about it, we were talking about how an object oriented programming approach may be a better solution for some of these new settings and defaults. Currently, we build and break, build and break (speaking about pulling and accessing settings). It may be nice to keep and hold some of the persistent or permanent settings and features. An object oriented model may be better equipped for that type of transaction. Currently, we look things up just in time. In the future, we may need to catch and hold those settings and maintain them in the user's session (stored in memory) options.

Eric popped in and we did some check in and follow-up with his code review on the sub special account tracking project. This project is a sub of the balance sheet and deals with special accounts (mini bank account type objects) like customer loyalty points, gift cards, in-store credit, etc. That project is promised by next Monday. I will be trying to focus on the code sign-off this week.

After that, Eric and Steve and I started talking about some of the new look and feel, CSS, and user interface stuff that Eric is wanting to help with. Both Steve and Eric were talking about a virtual "Adilas Cafe" or a global landing spot for the adilas users. This all goes back to separating the users from the main application code. There will still be a tie-in, but we are seeing a bigger need to keep users on the outside as a single entity and then allow them to go in and work or be a part of a corporation. We have many users that  have and/or will need access to multiple corporations, and even be able to bridge across physical servers. Currently, our model is based on users per server and then tied to corporations based on active permissions to those corporations. We are seeing a need to break that down even further and have a master or global user id (virtual pool of users) and then allow them to be bridged to different corporations on a more global scale vs just per server (physical box) vs the possibilities of dynamic cloud networks.

As we got deeper into the conversation about the potential of the Adilas café type model, we were talking about doing mock-ups, flow charts, etc. Eric had some questions about authentication servers and how that would all roll into the mix. We told him that he would need to get with Wayne to get more details. As we talked, we decided that Eric and Wayne should work together in a mini team type environment. As we explored the options, some of Steve and I's concerns (listed at the top of this entry) started to go away. We ended up somewhat asking Eric to be a project manager type role for this transition project between Newtek and AWS. That little tweak in the plan and how the developers were paired up, made a ton of difference and some of the anxiety started to go away.

We need to crate a list of specs for Wayne and what we want the application to do. Plan and play as if for years. We also talked about in-house coordination and communication. That is a huge key and helps all parties involved. Steve was talking about skating to where the puck (pretend we are playing hockey) is going to be. He and Eric were talking about the existing login pages and the corporation chooser page as being the beginning of the adilas café (landing spot or centralized common ground area). Good discussion.

We would really like to keep pushing the ball forward and making each system its own entity. This means having a centralized database controlling users and access to different corporations and/or entities and then having the individual entities having their own database or system for just their stuff. Currently, there are a number of tables that are shared between parties. For speed and efficiency, we really need to split things up more. This may also affect how we are able to bill for storage and processing vs a set monthly system fee. Anyways, as the conversation progresses, Steve and Eric were talking about using the choose corporation page as the starting common spot or commons area. Steve was also saying that he would like the users to be able to go to work (assigned or authorized corporations) as well as go play (demo sites, play grounds, or play sites). Basically, anybody could have an adilas account, and then they could either go into a real site (aka work) or a play site (aka play and testing). Fun ideas.

One of Eric's and Wayne's first item of business will be to do a virtual inventory check of where things are at on the project and what will still be needed and/or stands in the way. That will be awesome. It really was an mini answer to prayers that we decided to team up Eric and Wayne. It helped us let go and be willing to embrace some of the unknowns. As part of that, we are hoping that having the guys work together in mini teams helps us prioritize what really needs to be done and when. Sometimes, by yourself, it is hard to know what needs attention first, especially if it feels like everything is vying or trying to get the input, attention, and/or priority. Crazy stuff, I'm been there before and will be back again.

Steve and I talked about cycling through hardware and how that is just part of the line of work we are in. Later this year, we will need to buy some new laptops and upgrade some of our development environments.

One of the breakthroughs for today was the mini team concept. We have Steve and I, Steve and Dustin and Josh, Brandon and Alan, Wayne and Eric, Shari O. and Pat and Drea, etc. There are starting to be all kinds of little teams. That is awesome.

Shawn popped in and reported on some payroll updates and changes. We scheduled a time to meet again tomorrow. He is also willing to help me out with some of my projects and such. After that, I spent the rest of the session recording notes and trying to get caught up (as good as I could).

On the morning meeting with Steve and Dustin. Steve had some questions on a page he was working on. We looked at a query and made a couple of changes. We then chased down a small bug that ended up being a user error, not a bug. We pulled some data and Steve took some notes to let the client know. Towards the end of the meeting, both Steve and I helped Dustin with a small fix on his local environment.

Dustin and I worked on his cultivation phases and getting some of the queries and filters a little bit tighter. He already had them in place, we just helped get things a little bit tighter. After doing the phases and phase counters, we switched and worked on the location counters section. All of these pieces are in a section called cultivation that he and Steve have been working on for months and months. It is really looking good.

Eric joined the meeting and had a couple of questions. I really appreciate that fact that he tries to look global or general adilas before just making a one-off custom report. His questions were dealing with showing discounts, discount ranges, min/max discounts, etc. He also had another request for some sub inventory and RFID tag reports. We talked about options and also talked about custom dashboards that have prebuilt buttons that allow our users to get to the reports that they need and want within a single click (precode the buttons and/or page links to contain the filters and search criteria.)

Working with Shawn and getting him setup on a new branch. Shawn and I also talked about two new projects that are coming up. He will be doing Oklahoma taxes and withholdings and the two of us will be working on the invoice due date project (old one that Russell and I were working on middle of last year). We need to pick that project back up. Called and talked with Calvin.

Facing some legacy issues... validation length on certain characters and strings. Also a conversation between old legacy code (adilas classic) vs the new fancy code (adilas snow owl) and updated features. We talked about even having some different pages and allow the users to choose between generation one, two, three, etc. (page versions and compatibility levels). We may end up using the corp chooser pages (special links and pages per corp) and point people to different files or different versions. On the code side, it becomes harder and harder to maintain and update multiple pages that provide different levels of functionality.

Steve and Dustin were working on some changes and restoring and creating some page variations (legacy code issues discussed above). Meanwhile, I was working on lowering the validation limit on PO and invoice line items. The old code required the line item description to be at least 3 characters in length. However, an item number or part number only had to be a minimum of 1 character. We were having problems with users creating a 1 character item and then not putting a 3 character description. The normal pages stopped any of that from happening, but we have some code that auto builds certain things and fills in default values (makes it quicker). The new auto build code didn't have the same validation. In order to help standardize, we actually lowered the required characters on the line description to allow both sets of code to work without any issues. Constantly refining piece by piece.

Alan came on to the morning meeting and gave Steve and I a small demo of the new merchant customer homepage. This is for reoccurring credit card payments and tracking some customer information that are scheduled as a reoccurring and/or subscription type payments or reoccurring invoices.

Steve and Dustin were working on some Metrc changes and fixes. I was working on a list of topics and questions for Wayne and Eric dealing with the transition between Newtek and AWS (amazon web services) stuff. See attached for a starting list for our conversation.

Wayne actually joined the meeting and we went for over an hour and half going over some of the topics dealing with the transition between Newtek and AWS. See the other attachment for a current working document with tons more details.

Dustin and I met up on the morning meeting. We touched base and setup a meeting for Thursday afternoon to work on his cultivation stuff. He is doing great and has been a good team player.

I started working on some code review. Didn't get very far. Both Alan and Wayne popped in.

We went through a whole new section where Wayne was explaining and showing us what was going on out in the AWS land. Wayne was the presenter and was showing lots of things. Alan was asking questions and I was taking notes. See attached for the latest notes.

Steve and Eric popped in later on to listen and chime in. Wayne was showing some of the Docker image stuff. He was also helping Steve look at a server and find out what was going on. Good stuff.

Need - drop shipping and special tax tables for that drop shipping

We also had a client express that they wanted to be integrated with a number of other outside ecommerce type systems. Steve was using the analogy of having multiple fishing poles in the water (this ecomm package, this other ecomm package, and this other one - get more clients from different sources and areas).

At the end of the session, Eric and I went over the progress on the code sign-off project for special accounts and special account tracking (customer loyalty points, gift cards, etc.). Still working on things, but making progress.

Pretty quiet morning. Dustin and I were on the meeting but mostly working on our own stuff. He did have me help push up a file to a server for testing, but other than that, just getting going and working on our own projects. I spent most of the morning working on the add/edit page for manual transactions for the corporation special accounts (things like customer loyalty points, gift cards, etc.).

Working with Dustin. We were having a problem with submitting bulk form data and then the system not maintaining the correct sort order. It was still doing all the right stuff, it just needed some light refinement. We worked on submitting things in bulk, then resorting it, and then doing the normal actions. Good stuff and a great session.

- Who can help Kelly? She needs access to a developer.

- One of her main requests is getting data out of the system. One page that she would like is a full parent inventory with all flex grid fields. See the top_secret/custom/full_customer_list.cfm page for a sample that does the same thing but for customers and flex grid.

- Pieces of pie analogy - and who gets access to those developers and how do we get everything tied back together.

- Symptoms of the problem - a non whole-listic approach

- Kelly is having to take the information out of the system and run her own reports

- Two main parts that Kelly wants tracking money and tracking inventory

- What are the minimum levels for a code developer? Looking for talent. Kelly and I talked about beginners, intermediate, and advanced developers.

- Project management software for adilas

- We need money and funding to keep going

- We need to focus on our own system and get it across the finish line as a product

- The model of independent consultants and/or developers can get very scary - the scary part is the inconsistency of how the money comes in - somewhat of a feast or famine type feel

- Developers: Wayne, Alan, Eric, Calvin, Bryan, Shawn, Josh, Dustin, Brandon, Will, Steve

- People believe in the tool and like what they are doing

- In order for adilas to get bigger, we will have to change some things

- Revisiting the entire business model

- Investments - pros and cons - period for two year (funding numbers)

- Let's setup a whiteboarding time and come up with a new model

Steve had some questions and updates. Working in AJAX and JQuery and having Dustin do some cross training and helping Steve with some of the new technologies. He is also working on some new production stuff and even possibly looking into tying in full recipe/build type stuff. Some of that is getting pretty deep.

Dustin is going to be adding more subs of elements of time to help with his harvest pieces. He is going to be using sub flags and tags and adding some new harvest types. They are already doing sub phases, sub groups, and now sub types. That will be really cool.

Eric popped in and had a number of questions about sub inventory through adilas API sockets. We ended up talking about the need for better and better documentation and someone to help with API socket stuff and keeping up with documentation. We also have a number of projects that are done and need to be pushed through the code sign-off process. There are a number of projects that have been put in my court, but I just haven't gotten to them yet.

Wayne popped in and gave us an update on some of his AWS transition stuff. We talked about which companies were going to be pulled over for some live testing. Wayne gave us an update on the document and image processing stuff. We also talked about some new functions and how Amazon is starting to build up a giant community of alternate functions and globally accepted options. We also had a fun futuristic talk about AI (artificial intelligence) and using computers doing translations (languages), OCR (optical character recognition), etc. Lots of good stuff going and coming down the pipeline.

Wayne and Eric are going to be working together on a few things. That is awesome. We are going to be changing from an application .cfm (auto include file) to an application .cfc (auot include component). Getting things ready for a single corp structure (splitting corps out to separate database - world building concepts). We also need ways to build in the payee/user integration stuff. There are potentially a number of duplicated records out there.

Steve was telling me some stuff about sales and where things are going. We then talked about some of the other developers who are out there, both established developers, and also the ones that are hanging around and may be very valuable, based on their skills. We specifically talked about Shawn, Spencer, and Josh. Those are some developers who have already played the game and could go even further.

Steve and Josh were talking about an "inventory engine" (max, mins, reorder process, etc.). The inventory engine would help manage the re-ordering of inventory and reporting on inventory levels. Currently, this is just going to be some settings based on a per category level of what is needed (eaches or grams). Think of algorithms of how fast certain projects are being used, consumed, and/or turnover rates. Helping to automate the re-ordering process and even showing some forecasting on inventory items and levels. Helping the system tell you more about selling habits, turnover rates, and the virtual batting average of some of these items.

On sales (and in life), Steve loves to look at things in halves, thirds, quarters, etc. If you can break things down a bit, it becomes more manageable.

Wayne, Steve, Dustin, and I were on the morning meeting. Steve and Dustin were working on some JQuery and JavaScript stuff. Wayne had some questions about images and why each one was named a certain way. We talked about it and I prepared a document for him to show all of the different naming patterns for all 12 main application types. Out in the AWS world, things will be treated differently, so our existing structure and processes may need to change. The file that got worked on is stored in Wayne's folder on my local hard drive. It would be unwise to post it on this element of time at this point in time (our current processes are still in use).

After that, Steve and Dustin went back to working on some projects. Once they were done, we both helped Dustin with a small bug that he had and then we broke out into our own projects. I recorded some bills and started going through some emails. I added Pat Dolan to the approved adilas email names and options. Pat is helping us out with sales and what not.

Wayne jumped in and gave us a small demo of where he is at with the images. That seems like it has been a little bit crazy, trying to switch things over to AWS. The old way used ColdFusion and physically uploaded an image. Once the image was uploaded, it resized, renamed, and moved the images around where needed. The new process has to take the image, upload it to a single spot, then tweak it and save it out to an S3 bucket that is somewhat floating in the cloud. Not as stable (physical) as the old way, but eventually will be more powerful.

Dustin and I were working on some JQuery stuff for his pages. We ended up going back to a super simple test page type scenario to work on the pieces. It is amazing how if you take a super complicated piece and break it down to bare bones, you can play with it and learn vs getting completely overwhelmed. That is the value of a small test page.

Eric came on to the meeting and wanted to add a small form filter to one of the reports. No big deal, right? Well, he wanted the sales reports to be able to filter by customer type id (this is not a direct table value - we had to join other tables and then run custom filters). We also had to deal with form values, URL values, validation, flip/flopping between page scopes, drill-down links, button code, and other pages and tweaks. He had no clue that it would go that deep. We spent the next 1.5 hours following all of the cause/effect relationships for just adding a single form field.

I was gone for a couple of days. Most of the morning meeting was doing some catch up and getting back into the groove. We had a number of different developers pop in and give us updates. We had Dustin, Josh, Alan, Wayne, Eric, and Steve each give some reports. We answered some basic questions and then got to work.

Shari O. and Drea were also on the call. They let us know about a tech support issue that needed some loving (small error or bug). I then started to work on that bug. It was dealing with sub inventory attributes and being able to dynamically search by the attributes. The value in question was N11 (meaning the 11th numeric field). The old code had 20 custom text fields, 10 custom date fields, and 10 custom numeric fields. We are expanding it to allow up to 100 custom text fields, 100 custom date fields, and 100 custom numeric fields. That is just a number so that we keep it in check, technically, it could be pushed further, we are just taking smaller steps.

Pretty quite meeting this morning. Dustin checked in and then bailed out. Alan jumped on and gave me a small report. We also spent some time looking at the custom tables for holding sub inventory attributes. We talked about some possible rework options and helping that process. We logged into a server and looked around at database activity, column counts, row counts, and basic database stuff.

I got back on the code review and code sign-off for the special account tracking project. This deals with things like customer loyalty points, gift cards, in-store credit, etc.

On the morning meeting with Steve, Eric, and Dustin. Steve had a couple of questions about some new logic that he was building. It was dealing with looping over the form scope and getting counts and counters from that process. After that, Eric had a number of questions. We talked about adding in drill-down links to the new sales numbers on the daily/weekly sales summary pages. We then got into some needs on the API socket side of things. We needed to expand one API to include the web long description as well as add some samples and documentation to other API sockets. That whole section still needs a little bit of loving.

Eric and I started actually doing some of the work on the API sockets and pushed up a couple of small changes. Making progress, slowly but surely.

Getting started for a new week. Dustin, Wayne, Alan, Steve and I were on the meeting. We got some quick reports from the guys and then they all jumped off and started working on their own projects. Wayne is working on splitting up the corporations table. It has almost 400 fields or columns. That's a big table with tons of settings. Alan was talking about some of the automation with merchant processing and USAePay. We also talked about maybe holding the corp-wide settings in the session scope and maybe even storing some of the sessions in a JSON type object.

Steve and I had a good conversation about the transition over to AWS and all of the changes that are happening. There are lots of exciting things but there are also some unknowns. We were talking about back-up plans, what would it take it we had to make a turn this way or that way, etc. Lots of what if's and trying to look objectively at what is coming down the pipeline. I did a lot of drawing and tried to explain what changes I know about and how I interpret those changes. I think that helped, but we are still going to contact Wayne and try to get some more information and/or make a good plan.

Eric popped in and we worked on some API socket connections. He has a new project that he is working on that is a 3rd party solution that wants to integrate with adilas and get certain sales data passed back to them, based on who signs up for their services. We did some prep work, found some good examples and handrails (code and logic samples), and started building an outside scratch file to do some testing. In the scratch file, we were only pulling in the minimal requirements and pieces. A great start.

Just Dustin and I on the morning meeting this morning. We talked about some of our adventures and shared some photos and stories. Fun stuff. After that, we split up and started working on our own projects. I was working on the percentage calculation page and using the new calculations in populating an add item to cart page. Finished up the percentage calculation project and pushed up new files. I also updated help files and cascaded changes to all servers. See the gallery for a couple of screen shots.

Interesting turn towards the financial end of things. Steve reported that he had a great meeting yesterday doing some deep financials and balance sheet stuff. He was talking about internal builds, internal payments, flex grid, reflexive side of the flex grid, elements of time, etc. Lots of tools to help thread the story all together and have everything show up and flow through the whole P&L and balance sheet. As a side note, I was in deep yesterday on the backend balance sheet code as well. Kinda fun and interesting.

Steve and Dustin were working on cultivation stuff, while I was burning back-up DVD's. I have to upgrade my laptop and need to have all of my files backed up.

Steve and I were talking about education, training, and options that exist there. Adilas creates so many opportunities and virtual byproducts. At some point, someone will pick up some of these opportunities and virtual byproducts and run with it. Good for them and they will be able to make it. That is awesome.

On the morning meeting with Steve. We did some quick catch-up and then onto our different projects. Dustin popped in and out. Wayne had a couple of questions. We need to make the main login more session based, in order for the code to transfer better out to AWS (amazon web services) land. After that, Josh jumped on a had some code repository questions. I then took some time and built in a session corporation key as part of the main login process. I'm hoping that will help out Wayne with his AWS transition stuff. We also set up some additional time for tomorrow.

Basic to do list stuff and emails.

Got with Dustin and helped to do some code review and code merging. Got all of the new files (all in the custom folder) merged in and pushed online. He is doing a great job and I really thank him for his efforts. He is super easy to work with. That helps a ton. Good stuff.

Wayne and Dustin were on this morning. Wayne had some questions about logos, images, and look and feel stuff. We got over to the AWS stuff and did some testing. Only certain users were working on the new stuff. We re-flipped things back to the data 0 box and he will do some more debugging and testing. We lightly postponed our active testing until another day.

Steve, Dustin, Wayne, and I were on the morning meeting. Wayne was working with the guys on some of the changes out in the AWS land stuff. Once I came on this morning, Steve and Dustin jumped off to work on a separate project. Wayne and I talked about some logo and image changes and then some update queries. After that, I did a local database back-up and got ready to uninstall and reinstall some database servers.

Bryan, Molly, and Eric joined the meeting. They were talking a lot about 3rd party solutions and who pays for what. We also talked about some needs for sub inventory. We need API sockets, documentation, more integration models, etc. We even started talking about 3rd party solutions and diverse plug-ins and how to best help that model out. Not all solutions are worthy of spending the time to fully integrate. We want to enjoy working with these other companies.

Molly is looking to expand the searchability and export options for sub inventory. They have done some foot work and worked on a custom export for sub inventory. They would love to bring some of that more into the core process. Currently, a lot of the filtering is done from the parent level down to the subs. We are seeing a need for being able to filter from the subs up to the parents (reverse filtering). We briefly talked about adilas and that we will be doing a new adilas funded round on sub inventory. Currently, we have done 3 full rounds on the sub inventory section. We will be bringing in Alan Williams to help with this project. Before we jump, we are looking for a proposal and/or a plan for going forward.

The conversation started going towards... what is coming up next both with adilas and in general. The landscape keeps changing. What are the priority on the different projects that are coming down the pipeline? Molly was expressing some of her priorities and where the needs are.

Pagination vs grouping - Going back to sub inventory... We need exports and searches on parts, items, sub inventory, parent attributes, sub attributes, etc. To sum it up, we need better reporting on sub inventory and everything that it touches.

Towards the end of the meeting, Steve and Dustin were working on some custom reports and I was working on new install stuff for my local environment.

Working with Dustin and Steve on some debugging on their cultivation stuff. The bug we ended up finding, after tons of searching, was dealing with text comparisons vs id and settings comparisons. It got pretty deep. 

After Dustin and I got done debugging some comparisons between settings and sub inventory attributes, Wayne and Eric popped into the meeting. Wayne was just checking in and letting Steve know that more progress was being made in the AWS land stuff. Eric then had some questions about a 3rd party API socket project that he was working on for a company called Spring Big.

Basically, if a company turned on this 3rd party solution, it would share and pass both customer data and invoice data over to Spring Big. I'm not sure of all of the details, but it seems that they did some marketing and offered some coupons and/or campaign type offerings (don't quote me on that - just going by impression). Anyways, Eric and I were looking into new custom code and debugging some of the API calls and internal methods. He has a pretty deep wrapper function that have a number of other sub routines and sub API socket calls. We spent over an hour looking and testing things. We found our bug and fixed the issue. Towards the end of our session, he was checking API socket calls, pushing data, updating data, and finalizing transactions. Great progress.

At the end of the work session, Eric left and Steve and I started working on some of his projects. We spent about an hour looking into his (Steve's) and Dustin's cultivation code and the phases tab (changing plant phases section or sub section of the main cultivation homepage). We did some debugging, added some page and query filters, and commented out some older code. We tested both locally and push things up live. We have a client that is pushing the limits of what we can get the system to do without timing out. We also spent some time talking about ways of changing the existing page structure, carving the code and output into smaller pieces, and using more AJAX (asynchronous JavaScript and XML) type technologies for breaking pages into smaller chunks of data. Lots of potential there.

There were quite a few people on the morning meeting this morning. We had Steve, Dustin, Wayne, Shari O., and myself. We started out and Wayne wanted to get a standard spot to report and handle issues and bugs for the transition to the AWS stuff. We setup an element of time and will be using the sub comments and notes to record any issues and/or bugs.

After that, Steve and Dustin wanted to go over the cannabis cultivation homepage and figure out where we could speed things up. See attached for some notes. The main take away from the meeting was user designed, single pagers, let users control the flow of data based on clicks and events, and use AJAX (asynchronous JavaScript and XML) type interfaces. The conversation turned lightly to aggerated data (pre-summed up data) vs transactional data (individual details). We would really love to keep heading more and more in this direction.

Shari O. was talking about some communication issues between our clients and the reps that support them. We had an issue last night when we had to turn a client's system off. We had contacted the client and they were over 3 months behind on monthly payments. We shut them off (the companies system) and then crap hit the fan. The client was open 24 hours a day. Anyways, we had a rep that got on the phone and was ripping our tech support people a new one. We had some talks about how we need to use the system to be the bad guy. We have a project planned that will show prompts in the page headers and will let them know that they will be shut off if they get past a certain date. We need to get back to that. If we could get this project done, it would save a lot of headaches.

Shari O. was talking about some team work and playing as a team. We have some great people who help and participate and some that don't do much. We have a spectrum of different people all around.

This is both funny and sad, but sometimes we really feel like the little red hen - who wants bread? Me, pick me. Ok, who wants to help me plant it? Not me, not me. Ok, who wants to help me harvest this stuff? Not me, not me. Ok, who wants to help me with (fill in the blank)? Not me, not me. Ok, I guess that I'll just do it my self. Suddenly, we get the bread done, and everybody wants it. There is some truth to that.

Steve was expressing some concerns that he is getting behind on his email stuff. We had some light talks about what needs to happen there and how best to structure our team. At a certain point, you almost give up and/or can't keep up. The mountain keeps growing and doesn't seem to stop.

Back on team building stuff... we are trying to help and train our guys and gals to work as independently as possible. There are constant needs that just keep coming. It gets pretty crazy. Back on the email stuff, maybe we need to use more of a standard like "support@adilas.biz" or "info@adilas.biz" and then let it get filtered out before it hits all of us. Steve really wants us to use technology to play this game. More automation and more ideas and options. Lots of tag team stuff. We are also learning along the way. Lots of new lessons being learned and hopefully applied.

Steve was talking about dependables and who is playing with what and who is doing what. We have a very independent model. That is awesome but does have some challenges as well. Steve would like his sales focus to be more on the white label type arena.

Alan joined the meeting and gave us an update with USAePay and there EMV chip reading and chip processing. We may end up having to integrate with FirstData as a merchant processing account (more gateways). We currently offer some chip reading options, but it still kinda random and small ball of strings. There is a growing need on the merchant processing and gateway stuff (credit card processing and chip reading technology stuff). This is way out there... but maybe at some point adilas will be their own merchant processing gateway (some sort of internal solution). Alan volunteered for this project (just kidding).

Towards the end of the session, Eric jumped on and needed some help with some queries of queries, complex data, and getting some data tables setup for his custom reports. We also scheduled some other time next week to work on sub inventory and API socket documentation stuff.

Working with Drea and Dustin on a small bug with the cultivation homepage. We had to log into the remote server and run some check-up queries. All three of us were working together and changing who was running with the presentation. Dustin had his code editor open, I was logged into the remote server, and Drea was logged in as a user in the corp that was having issues. Good team work. We got it fix and did some light checking. 

Another fun day on the adilas farm... We had Steve, Dustin, Eric, Wayne, and I on the morning meeting. Dustin was reporting about some of his new AJAX stuff on his cultivation pages. He is trying to break that page and flow process into smaller bite size pieces. Steve had a few questions on some of his bulk page clean-up tools (bulk close sub inventory packages that had a 0 quantity and were set to show - disabled). We looked at some queries and made a few minor tweaks. He is doing great. Eric had a couple of questions. Steve had some 3rd party API socket settings stuff for Eric and I. There is also a Lots of moving pieces out there. Steve also let us know about a possible project that would be funded by an outside party that deals with an API socket connection between Woo commerce, WordPress, and adilas. Wayne was checking on our AWS transition testing and making some tweaks. Lots of good stuff.

As a side note, there were some small discussions about security and liability of our clients using the adilas API sockets. We also talked about other outside parties using the same API sockets. We have to maintain who authorized what access and who virtually opened the data window/door. I told Steve that I would like to keep the API sockets open and increase the options to use them. He was worried about both security and liablility levels and wanted to know how some of that stuff works and/or is setup. We covered the basics and even went over a few scenarios. We had a brief, but good talk on the subject. As a follow up, we will be doing a mix between a full 3rd party solution and a custom black box for a single client and their mini 3rd party provider (kind of a hybrid of sorts - just for a single corporation). The important thing is, we will be tracking all of their data requests via a custom and special id number (this will help with the audit trail).

We had a few of the guys on the morning meeting this morning. We had Steve, Dustin, Wayne, and Alan. We started out and Steve and Dustin were going over some of their new cultivation code. Dustin is already breaking up the page and adding in some AJAX (asynchronous or non-linear database calls) stuff. This will really speed up that page and alter the flow. Steve and Dustin were sharing some code back and forth and getting certain pages updated.

After that, Wayne had a few questions about some legacy look and feel pieces. Most of it was how we managed the corporation id number switches and why we did what we did. Some of the older code would change look and feel based on who was logged in, whether or not they were logged in, and what corporation was asking for what page. We are looking to get rid of some of that older code and make it more standard.

Alan had some updates on his merchant processing stuff. He is heading into the refund and refunding realm. I tried to let him know about a few of the pit falls and crazy scenarios that could happen out there. As a take away, we ended up talking about time lines, cause and effect, life cycles, and digital storytelling (tracking what physically happens and how we track that digitally). I really wanted Alan to automate what he can easily and then leave some of the crazy things to human intervention (manual transactions and manual processes). We don't want to speed up the flow of monies going out too much. That could be abused, misused, etc. Lots of drawing and small models and scenarios.

The next topic of the morning was the invoice due date project, that Russell and I started back in December of 2017. Alan and I talked ideas, concepts, theory, and how all of those pieces tie in. This project would really help out our own internal people that have to collect monies and do accounts receivables stuff. The overarching goal is be able to set an invoice due date and then monitor aging according to that date. Once an invoice gets to a certain date, we could virtually let a client know (say through a header feed or something like that) some kind of action was needed (payment needed). If we use the warning system correctly, we could also have standards for all kinds of processes and/or procedures. This includes when we turn systems off, for not paying, or warn when invoices are certain days old, etc. Basically a notification process based on invoice aging and monies due. That project has had a lot of work done on it, but it currently is sitting in code branches in the code repository (aka code sitting on the shelf).

Steve and I looked into an AJAX feeder that Steve is using on one of his pages. The page was working one way but not another. After some testing, we found that the way it wasn't working was because of a miss spelling. No error handling was being done and the error was going undetected. Once we fixed the spelling error, it allowed us to get at the new data we were trying to harness and get to. Crazy how sometimes it could be as simple as a missing letter or a 1 switched with a 0 and things may or may not work. Lots of detail work.

Dustin and Alan came on the meeting at different times. Mostly just to check in and report. I was back on the transitional invoice project and light tweak on the balance sheet dealing with the way we show the transitional invoices (QTI invoices). Towards the end of the meeting, Eric joined the meeting looking for Wayne.

Mostly just Steve and I on the meeting this morning. Dustin and Eric joined for a bit but today was mostly a work session for Steve and I. Normally, we have Wayne help with all of the data migration projects. He was out travelling today and won't be back in until Monday. Anyways, Steve and I had two new corporations to setup and populate with data from other existing corporations. I spent some time and updated a bulk parts/items copy tool and got Steve using that tool to migrate parts and items from one corporation to another. I then worked on a customer (patient/visitor) upload file that they provided and got it all prepped and ready to do a data migration for the customer records. I migrated close to 7,000 customers from a spreadsheet into two different corporations on the data 7 box. We had to do a little bit of custom stuff and all of the records had about 5 flex grid tie-in fields to go along with the normal records. Once again, mostly a work day today, so far. Time for some lunch.

Worked with Dustin to merge in 8 new files from his code branch. Lots of his code was dealing with breaking up a bigger page into smaller asynchronous data calls using AJAX and loader images. Great breakthroughs. Steve and Dustin spent some time testing and making notes on other things that could be sped up. They were excited about these new changes.

Pretty quiet morning meeting. Dustin, Wayne, and Eric were on a different times. Mostly just checking in. Eric and I were working on finishing up the small project of adding sub inventory to the getWebGeneralInventory method (API socket). We got it working and I pushed the files live and let Eric know.

It may not sound like much, but it combines six different queries into a complex data object. The six different queries are: get the main or parent items, get the sub items (child items or packages), get the sub attribute names and titles, get all of the text based attribute values, get all of the date based attribute values, and get all of the numeric based attribute values. Then you have to loop over the different pieces (conditional nested loops) to construct and make the data reassemble in order to get a readable output. After all of that, you still have to convert it into JSON or XML (web readable formats for the adilas API sockets).

Busy Monday morning. We started out with Josh joining us and giving us a small report. He is working on some custom reports and making a few changes to the discount engine and the inventory engine projects. We setup a time to do some code review and sign-off for this coming Wednesday.

Alan gave us an update on automation of USAePay (merchant processing) and reoccurring billing stuff. He has a client wanting similar reoccurring billing options built out for another gateway called Converge and Converge Connect. Alan also gave us an update on the invoice due date project, using internal universe API sockets, refactoring sub inventory, taking corp-wide settings out to a server scope memory cache vs direct database pull every time. That should be a good time saver and be more efficient. He was also talking about some new getters and setters (ways of pushing and pulling the data in smaller direct pieces). Cool stuff and he seems to be making progress.

Dustin and Steve were talking about AJAX (asynchronous connections) and how some of the new changes have really sped things up with one-pager interfaces and loading graphics, and faster more direct database look-ups. Dustin was volunteering to add some of these asynchronous calls to other pages and reports. By way of definition, a normal synchronous (or in-line) call means that you go ask for some data and you wait until you get everything back. Think of one giant clump of data being returned. You then report back to the browser or user and show the page. An asynchronous call (or on-demand as needed) allows you to return basic information and structure very quickly (the user will see something on the page). It then uses asynchronous calls and connections and fills in data as it can and/or as it gets returned. This is great for data that may be a subset of the main data and/or you want a user to click or interact to see additional results. It is a way of breaking up the data and speeding up the loading and display time. Great stuff and Dustin is doing great on some of his sub projects.

After that, it was just Steve and I on the meeting. We talked about a number of different topics. We have been doing more testing out in the AWS (amazon web services) land and getting things ironed out there in AWS land. Wayne is doing great and making awesome progress. Steve and I setup some time for tomorrow to work on balance sheet related project. We are going to be diving in deep and looking at how certain values are being tracked. That small conversation brought up some other topics such as caching, efficiency, moving more towards aggerated (summed up data) type transactions, etc. We are seeing more needs for watchers, feeders, triggers, etc. We even talked briefly about the underlying goal of getting all of the data organized into a 3D calendar of sorts. Fun to bounce back to past ideas and concepts. Good stuff.

Eric called in and was out on the road. He had a couple of questions and gave us some updates on some custom 3rd party solutions and custom reports that he is working on. As an interesting side note, some of the comments between Eric and Steve had an interesting undertone. Nothing negative, but definitely complex and cross-corp oriented. They, both Steve and Eric, are working on custom consolidation reports, cross-corp reports, and even multi-corp syncing. The deeper we get, certain clients are wanting to standardize data across platforms, across systems, and even across servers. It is getting more complex and we are seeing needs where we may have a master corporation and then being able to cascade certain data from a master corporation setup to an unlimited number of sub or slave type corporations. We are seeing both data and reporting needs that need to be synced between multiple corporations. This syncing type need is in an effort to help with collaboration and standardizing data across systems. Almost getting into a data warehousing type need or data warehousing type environment. Kinda interesting.

After Eric, Bryan joined us and had a few questions for both Steve and I. He is working on custom gram tracking (subs of the shopping cart) and taking certain gram tracking settings and helping them cascade all the way over to custom label building. It is interesting to see the levels of customization and the needs that some of these clients are expressing. The scary side to that is... how far are we willing to go and what will that take? Custom is potentially a huge swinging door. Awesome, powerful, but potentially bigger than we would like.

In between these different little meetings. I finished up the documentation to go with the getWebGeneralInventory API socket method call. I was working on that project last week a little bit. I added a small working document (to do list and brainstorming doc) for the small changes and to help with the project scope. Nothing major, just wanted to record it. Busy morning. It must be Monday.

Eric popped in and gave us an update on some things. As an observation, it is amazing how much some of our reps and consultants fill in the gaps between the system and the education and training that is needed. Eric is working lots and lots with some of the 3rd party solutions and outside API sockets.

Next, Dustin and I worked on some reports and showing dates and ages between different phases for his cultivation stuff. We ended up doing different queries to get the dates, then logic to see if they were real or not (had it really happened), and then showing the age calculation in the reports. Kinda fun little challenge.

Monday morning. We started out with a couple of questions from the guys. Steve had some questions about getting his quantities correct as part of the transfer invoices that he was doing in his production code (mini manufacturing). Wayne has some questions about our use of the application scope and application pages within the adilas site (big picture architecture). Dustin had a query that was returning too many rows and some with duplicate info. We ended up having to do some deeper grouping in order to get it corrected. After that, Steve had me help make sure that a valid user was setup on multiple servers to allow an adilas rep/consultant to login to multiple servers with the same username and password.

After that, I checked some emails and tried to get things flowing on the normal day to day stuff. Worked on inputting my schedule for July. Lots of crazy stuff this month. Random here and there.

Working with Steve and Dustin. We fixed a bug with a query that was dependent on another query. The problem was that the first query wasn't returning any results and it was making the second query fail. We fixed that and then the page was good to go. We also went in and had to fix a 3rd party white label problem. As part of that fix and conversation, we talked a little bit about the adilas 3rd party solutions, white labeling solutions, and other topics. The deeper we get, some of that stuff kinda gets out of control. Not too bad right now, but you can see some writing on the wall and some definite needs starting to develop.

Adilas and the adilas platform keeps creating these service based byproducts. The more people we have around to pick-up these byproducts, the better. There is so much business out there... you just have to see the need and then fill that need. The system keeps creating multiple byproducts that could support their own business and/or multiple businesses. So many different segments of how the system creates all of these options and opportunities.

On the morning meeting with Steve and Dustin. We worked on some small image tweaks for Steve and his custom sales icon reports and then talked about AWS and progress out there in that area. Towards the end of the meeting, Steve and Dustin were starting to work on how to look up sub id's from data that exists.

Steve gave me a call this morning. I joined the meeting and Dustin was on, but I put a note on my screen that said that Steve and I were on a phone call. Dustin stayed on for a bit and then checked out. Steve and I had a good little call. Some of the topics were:

- Lots of emails that need some attention - new systems, merchant processing API keys, etc.

- White label stuff with Pat, lead generation, emails - constant contact, offering managed services, so much opportunity.

- We (adilas) need to get into project management. There is a big need there.

Eric popped into the meeting and just touched base. He has been pretty burried with all kinds of custom stuff. He was asking what else was needed as far as internal adilas projects. We briefly talked about getting back on the loyalty points and special account tracking stuff.

After Eric left, Alan joined the meeting and gave me an update on what he is working on. He is currently working on the invoice due date project. As part of that, he is currently on a side project working on how we add in new corp-wide settings. He is reworking that whole piece of the puzzle and doing a great job. As he goes, he is taking older code and brining it up into more modern type classes, models, and more object oriented type approach. Good stuff.